--- /dev/null
+((nil . ((indent-tabs-mode . t))))
\ No newline at end of file
--- /dev/null
+# generic types
+*.o
+*.swp
+*.swo
+*.so
+*~
+*.dot
+.*.d
+*.pdf
+
+# files in this directory
+/tags
+/doc/docs
+/benchmarks
+/README.html
--- /dev/null
+To run inside MacOS under gdb you need:
+set dont-handle-bad-access 1
+handle SIGBUS nostop noprint
+
+To run in Linux under gdb, use:
+handle SIGSEGV nostop noprint
--- /dev/null
+# Doxyfile 1.8.0
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file
+# that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+DOXYFILE_ENCODING = UTF-8
+
+# The PROJECT_NAME tag is a single word (or sequence of words) that should
+# identify the project. Note that if you do not use Doxywizard you need
+# to put quotes around the project name if it contains spaces.
+
+PROJECT_NAME = "CDSChecker: A Model Checker for C11/C++11 Atomics"
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number.
+# This could be handy for archiving the generated documentation or
+# if some version control system is used.
+
+PROJECT_NUMBER =
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer
+# a quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF =
+
+# With the PROJECT_LOGO tag one can specify an logo or icon that is
+# included in the documentation. The maximum height of the logo should not
+# exceed 55 pixels and the maximum width should not exceed 200 pixels.
+# Doxygen will copy the logo to the output directory.
+
+PROJECT_LOGO =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
+# base path where the generated documentation will be put.
+# If a relative path is entered, it will be relative to the location
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY = doc
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
+# 4096 sub-directories (in 2 levels) under the output directory of each output
+# format and will distribute the generated files over these directories.
+# Enabling this option can be useful when feeding doxygen a huge amount of
+# source files, where putting all generated files in the same directory would
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
+# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
+# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
+# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
+# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
+# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
+
+OUTPUT_LANGUAGE = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
+# include brief member descriptions after the members that are listed in
+# the file and class documentation (similar to JavaDoc).
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
+# the brief description of a member or function before the detailed description.
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator
+# that is used to form the text in various listings. Each string
+# in this list, if found as the leading text of the brief description, will be
+# stripped from the text and the result after processing the whole list, is
+# used as the annotated text. Otherwise, the brief description is used as-is.
+# If left blank, the following values are used ("$name" is automatically
+# replaced with the name of the entity): "The $name class" "The $name widget"
+# "The $name file" "is" "provides" "specifies" "contains"
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF =
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# Doxygen will generate a detailed section even if there is only a brief
+# description.
+
+ALWAYS_DETAILED_SEC = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
+# path before files name in the file list and in the header files. If set
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
+# can be used to strip a user-defined part of the path. Stripping is
+# only done if one of the specified strings matches the left-hand part of
+# the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the
+# path to strip.
+
+STRIP_FROM_PATH =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
+# the path mentioned in the documentation of a class, which tells
+# the reader which header file to include in order to use a class.
+# If left blank only the name of the header file containing the class
+# definition is used. Otherwise one should specify the include paths that
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
+# (but less readable) file names. This can be useful if your file system
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
+# will interpret the first line (until the first dot) of a JavaDoc-style
+# comment as the brief description. If set to NO, the JavaDoc
+# comments will behave just like regular Qt-style comments
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
+# interpret the first line (until the first dot) of a Qt-style
+# comment as the brief description. If set to NO, the comments
+# will behave just like regular Qt-style comments (thus requiring
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+
+INHERIT_DOCS = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE = 5
+
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES =
+
+# This tag can be used to specify a number of word-keyword mappings (TCL only).
+# A mapping has the form "name=value". For example adding
+# "class=itcl::class" will allow you to use the command class in the
+# itcl::class meaning.
+
+TCL_SUBST =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C = NO
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for
+# Java. For instance, namespaces will be presented as packages, qualified
+# scopes will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources only. Doxygen will then generate output that is more tailored for
+# Fortran.
+
+OPTIMIZE_FOR_FORTRAN = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for
+# VHDL.
+
+OPTIMIZE_OUTPUT_VHDL = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given extension.
+# Doxygen has a built-in mapping, but you can override or extend it using this
+# tag. The format is ext=language, where ext is a file extension, and language
+# is one of the parsers supported by doxygen: IDL, Java, Javascript, CSharp, C,
+# C++, D, PHP, Objective-C, Python, Fortran, VHDL, C, C++. For instance to make
+# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
+# (default is Fortran), use: inc=Fortran f=C. Note that for custom extensions
+# you also need to set FILE_PATTERNS otherwise the files are not read by doxygen.
+
+EXTENSION_MAPPING =
+
+# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
+# comments according to the Markdown format, which allows for more readable
+# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you
+# can mix doxygen, HTML, and XML commands with Markdown formatting.
+# Disable only in case of backward compatibilities issues.
+
+MARKDOWN_SUPPORT = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also makes the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+
+CPP_CLI_SUPPORT = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
+# Doxygen will parse them like normal C++ but will assume all classes use public
+# instead of private inheritance when no explicit protection keyword is present.
+
+SIP_SUPPORT = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate getter
+# and setter methods for a property. Setting this option to YES (the default)
+# will make doxygen replace the get and set methods by a property in the
+# documentation. This will only work if the methods are indeed getting or
+# setting a simple type. If this is not the case, or you want to show the
+# methods anyway, you should set this option to NO.
+
+IDL_PROPERTY_SUPPORT = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+
+SUBGROUPING = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
+# unions are shown inside the group in which they are included (e.g. using
+# @ingroup) instead of on a separate page (for HTML and Man pages) or
+# section (for LaTeX and RTF).
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
+# unions with only public data fields will be shown inline in the documentation
+# of the scope in which they are defined (i.e. file, namespace, or group
+# documentation), provided this scope is documented. If set to NO (the default),
+# structs, classes, and unions are shown on a separate page (for HTML and Man
+# pages) or section (for LaTeX and RTF).
+
+INLINE_SIMPLE_STRUCTS = NO
+
+# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
+# is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically
+# be useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+
+TYPEDEF_HIDES_STRUCT = NO
+
+# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
+# determine which symbols to keep in memory and which to flush to disk.
+# When the cache is full, less often used symbols will be written to disk.
+# For small to medium size projects (<1000 input files) the default value is
+# probably good enough. For larger projects a too small cache size can cause
+# doxygen to be busy swapping symbols to and from disk most of the time
+# causing a significant performance penalty.
+# If the system has enough physical memory increasing the cache will improve the
+# performance by keeping more symbols in memory. Note that the value works on
+# a logarithmic scale so increasing the size by one will roughly double the
+# memory usage. The cache size is given by this formula:
+# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols.
+
+SYMBOL_CACHE_SIZE = 0
+
+# Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
+# set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
+# their name and scope. Since this can be an expensive process and often the
+# same symbol appear multiple times in the code, doxygen keeps a cache of
+# pre-resolved symbols. If the cache is too small doxygen will become slower.
+# If the cache is too large, memory is wasted. The cache size is given by this
+# formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
+# corresponding to a cache size of 2^16 = 65536 symbols.
+
+LOOKUP_CACHE_SIZE = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+
+EXTRACT_PRIVATE = YES
+
+# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal scope will be included in the documentation.
+
+EXTRACT_PACKAGE = NO
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+
+EXTRACT_STATIC = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES = YES
+
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base
+# name of the file that contains the anonymous namespace. By default
+# anonymous namespaces are hidden.
+
+EXTRACT_ANON_NSPACES = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
+# documentation blocks found inside the body of a function.
+# If set to NO (the default) these blocks will be appended to the
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS = NO
+
+# The INTERNAL_DOCS tag determines if documentation
+# that is typed after a \internal command is included. If the tag is set
+# to NO (the default) then the documentation will be excluded.
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
+# file names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
+# will show members with their full class and namespace scopes in the
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
+# will put a list of the files that are included by a file in the documentation
+# of that file.
+
+SHOW_INCLUDE_FILES = YES
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
+# will list include files with double quotes in the documentation
+# rather than with sharp brackets.
+
+FORCE_LOCAL_INCLUDES = NO
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
+# is inserted in the documentation for inline members.
+
+INLINE_INFO = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
+# will sort the (detailed) documentation of file and class members
+# alphabetically by member name. If set to NO the members will appear in
+# declaration order.
+
+SORT_MEMBER_DOCS = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
+# brief documentation of file, namespace and class members alphabetically
+# by member name. If set to NO (the default) the members will appear in
+# declaration order.
+
+SORT_BRIEF_DOCS = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
+# will sort the (brief and detailed) documentation of class members so that
+# constructors and destructors are listed first. If set to NO (the default)
+# the constructors will appear in the respective orders defined by
+# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
+# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
+# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
+# hierarchy of group names into alphabetical order. If set to NO (the default)
+# the group names will appear in their defined order.
+
+SORT_GROUP_NAMES = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
+# sorted by fully-qualified names, including namespaces. If set to
+# NO (the default), the class list will be sorted only by class name,
+# not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
+# do proper type resolution of all parameters of a function it will reject a
+# match between the prototype and the implementation of a member function even
+# if there is only one candidate or it is obvious which candidate to choose
+# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
+# will still accept a match between prototype and implementation in such cases.
+
+STRICT_PROTO_MATCHING = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or
+# disable (NO) the todo list. This list is created by putting \todo
+# commands in the documentation.
+
+GENERATE_TODOLIST = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or
+# disable (NO) the test list. This list is created by putting \test
+# commands in the documentation.
+
+GENERATE_TESTLIST = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or
+# disable (NO) the bug list. This list is created by putting \bug
+# commands in the documentation.
+
+GENERATE_BUGLIST = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
+# disable (NO) the deprecated list. This list is created by putting
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
+# the initial value of a variable or macro consists of for it to appear in
+# the documentation. If the initializer consists of more lines than specified
+# here it will be hidden. Use a value of 0 to hide initializers completely.
+# The appearance of the initializer of individual variables and macros in the
+# documentation can be controlled using \showinitializer or \hideinitializer
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
+# at the bottom of the documentation of classes and structs. If set to YES the
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES = YES
+
+# If the sources in your project are distributed over multiple directories
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES = NO
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page.
+# This will remove the Files entry from the Quick Index and from the
+# Folder Tree View (if specified). The default is YES.
+
+SHOW_FILES = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the
+# Namespaces page.
+# This will remove the Namespaces entry from the Quick Index
+# and from the Folder Tree View (if specified). The default is YES.
+
+SHOW_NAMESPACES = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command <command> <input-file>, where <command> is the value of
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
+# provided by doxygen. Whatever the program writes to standard output
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. The create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option.
+# You can optionally specify a file name after the option, if omitted
+# DoxygenLayout.xml will be used as the name of the layout file.
+
+LAYOUT_FILE =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files
+# containing the references data. This must be a list of .bib files. The
+# .bib extension is automatically appended if omitted. Using this command
+# requires the bibtex tool to be installed. See also
+# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
+# of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
+# feature you need bibtex and perl available in the search path.
+
+CITE_BIB_FILES =
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated by doxygen. Possible values are YES and NO. If left blank
+# NO is used.
+
+WARNINGS = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some
+# parameters in a documented function, or documenting parameters that
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR = YES
+
+# The WARN_NO_PARAMDOC option can be enabled to get warnings for
+# functions that are documented, but have no documentation for their parameters
+# or return value. If set to NO (the default) doxygen will only warn about
+# wrong or incomplete parameter documentation, but not about the absence of
+# documentation.
+
+WARN_NO_PARAMDOC = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that
+# doxygen can produce. The string should contain the $file, $line, and $text
+# tags, which will be replaced by the file and line number from which the
+# warning originated and the warning text. Optionally the format may contain
+# $version, which will be replaced by the version of the file (if it could
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning
+# and error messages should be written. If left blank the output is written
+# to stderr.
+
+WARN_LOGFILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain
+# documented source files. You may enter file names like "myfile.cpp" or
+# directories like "/usr/src/myproject". Separate the files or directories
+# with spaces.
+
+INPUT = . include/ include/atomic include/condition_variable include/cstdatomic include/mutex
+
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
+# also the default input encoding. Doxygen uses libiconv (or the iconv built
+# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
+# the list of possible encodings.
+
+INPUT_ENCODING = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank the following patterns are tested:
+# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
+# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
+# *.f90 *.f *.for *.vhd *.vhdl
+
+FILE_PATTERNS =
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories
+# should be searched for input files as well. Possible values are YES and NO.
+# If left blank NO is used.
+
+RECURSIVE = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE = malloc.c
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+
+EXCLUDE_SYMLINKS = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories. Note that the wildcards are matched
+# against the file with absolute path, so to exclude all test directories
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
+# the \include command).
+
+EXAMPLE_PATH = .
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank all files are included.
+
+EXAMPLE_PATTERNS =
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude
+# commands irrespective of the value of the RECURSIVE tag.
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or
+# directories that contain image that are included in the documentation (see
+# the \image command).
+
+IMAGE_PATH =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command <filter> <input-file>, where <filter>
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
+# input file. Doxygen will then use the output that the filter program writes
+# to standard output.
+# If FILTER_PATTERNS is specified, this tag will be
+# ignored.
+
+INPUT_FILTER =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis.
+# Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match.
+# The filters are a list of the form:
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
+# info on how filters are used. If FILTER_PATTERNS is empty or if
+# non of the patterns match the file name, INPUT_FILTER is applied.
+
+FILTER_PATTERNS =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will be used to filter the input files when producing source
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any)
+# and it is also possible to disable source filtering for a specific pattern
+# using *.ext= (so without naming a filter). This option only has effect when
+# FILTER_SOURCE_FILES is enabled.
+
+FILTER_SOURCE_PATTERNS =
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will
+# be generated. Documented entities will be cross-referenced with these sources.
+# Note: To get rid of all source code in the generated output, make sure also
+# VERBATIM_HEADERS is set to NO.
+
+SOURCE_BROWSER = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
+# doxygen to hide any special comment blocks from generated source code
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES
+# then for each documented function all documented
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES
+# then for each documented function all documented entities
+# called/used by that function will be listed.
+
+REFERENCES_RELATION = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code.
+# Otherwise they will link to the documentation.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
+# will need version 4.8.6 or higher.
+
+USE_HTAGS = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
+# will generate a verbatim copy of the header file for each class for
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
+# of all compounds will be generated. Enable this if the project
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX = YES
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX = 5
+
+# In case all classes in a project start with a common prefix, all
+# classes will be put under the same header in the alphabetical index.
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX =
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
+# generate HTML output.
+
+GENERATE_HTML = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT = docs
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard header. Note that when using a custom header you are responsible
+# for the proper inclusion of any scripts and style sheets that doxygen
+# needs, which is dependent on the configuration options used.
+# It is advised to generate a default header using "doxygen -w html
+# header.html footer.html stylesheet.css YourConfigFile" and then modify
+# that header. Note that the header is subject to change so you typically
+# have to redo this when upgrading to a newer version of doxygen or when
+# changing the value of configuration settings such as GENERATE_TREEVIEW!
+
+HTML_HEADER =
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard footer.
+
+HTML_FOOTER =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
+# style sheet that is used by each HTML page. It can be used to
+# fine-tune the look of the HTML output. If the tag is left blank doxygen
+# will generate a default style sheet. Note that doxygen will try to copy
+# the style sheet file to the HTML output directory, so don't put your own
+# style sheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that
+# the files will be copied as-is; there are no commands or markers available.
+
+HTML_EXTRA_FILES =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
+# Doxygen will adjust the colors in the style sheet and background images
+# according to this color. Hue is specified as an angle on a colorwheel,
+# see http://en.wikipedia.org/wiki/Hue for more information.
+# For instance the value 0 represents red, 60 is yellow, 120 is green,
+# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
+# The allowed range is 0 to 359.
+
+HTML_COLORSTYLE_HUE = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
+# the colors in the HTML output. For a value of 0 the output will use
+# grayscales only. A value of 255 will produce the most vivid colors.
+
+HTML_COLORSTYLE_SAT = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
+# the luminance component of the colors in the HTML output. Values below
+# 100 gradually make the output lighter, whereas values above 100 make
+# the output darker. The value divided by 100 is the actual gamma applied,
+# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
+# and 100 does not change the gamma.
+
+HTML_COLORSTYLE_GAMMA = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting
+# this to NO can help when comparing the output of multiple runs.
+
+HTML_TIMESTAMP = YES
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
+# files or namespaces will be aligned in HTML using tables. If set to
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded. For this to work a browser that supports
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS = NO
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files
+# will be generated that can be used as input for Apple's Xcode 3
+# integrated development environment, introduced with OSX 10.5 (Leopard).
+# To create a documentation set, doxygen will generate a Makefile in the
+# HTML output directory. Running make will produce the docset in that
+# directory and running "make install" will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
+# it at startup.
+# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
+# for more information.
+
+GENERATE_DOCSET = NO
+
+# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
+# feed. A documentation feed provides an umbrella under which multiple
+# documentation sets from a single provider (such as a company or product suite)
+# can be grouped.
+
+DOCSET_FEEDNAME = "Doxygen generated docs"
+
+# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
+# should uniquely identify the documentation set bundle. This should be a
+# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
+# will append .docset to the name.
+
+DOCSET_BUNDLE_ID = org.doxygen.Project
+
+# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+
+DOCSET_PUBLISHER_ID = org.doxygen.Publisher
+
+# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
+
+DOCSET_PUBLISHER_NAME = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
+# be used to specify the file name of the resulting .chm file. You
+# can add a path in front of the file if the result should not be
+# written to the html output directory.
+
+CHM_FILE =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
+# be used to specify the location (absolute path including file name) of
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
+# controls if a separate .chi index file is generated (YES) or that
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
+# is used to encode HtmlHelp index (hhk), content (hhc) and project file
+# content.
+
+CHM_INDEX_ENCODING =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
+# that can be used as input for Qt's qhelpgenerator to generate a
+# Qt Compressed Help (.qch) of the generated HTML documentation.
+
+GENERATE_QHP = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can
+# be used to specify the file name of the resulting .qch file.
+# The path specified is relative to the HTML output folder.
+
+QCH_FILE =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#namespace
+
+QHP_NAMESPACE = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
+# Qt Help Project output. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#virtual-folders
+
+QHP_VIRTUAL_FOLDER = doc
+
+# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
+# add. For more information please see
+# http://doc.trolltech.com/qthelpproject.html#custom-filters
+
+QHP_CUST_FILTER_NAME =
+
+# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see
+# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
+# Qt Help Project / Custom Filters</a>.
+
+QHP_CUST_FILTER_ATTRS =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's
+# filter section matches.
+# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
+# Qt Help Project / Filter Attributes</a>.
+
+QHP_SECT_FILTER_ATTRS =
+
+# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
+# be used to specify the location of Qt's qhelpgenerator.
+# If non-empty doxygen will try to run qhelpgenerator on the generated
+# .qhp file.
+
+QHG_LOCATION =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
+# will be generated, which together with the HTML files, form an Eclipse help
+# plugin. To install this plugin and make it available under the help contents
+# menu in Eclipse, the contents of the directory containing the HTML and XML
+# files needs to be copied into the plugins directory of eclipse. The name of
+# the directory within the plugins directory should be the same as
+# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
+# the help appears.
+
+GENERATE_ECLIPSEHELP = NO
+
+# A unique identifier for the eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have
+# this name.
+
+ECLIPSE_DOC_ID = org.doxygen.Project
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
+# at top of each HTML page. The value NO (the default) enables the index and
+# the value YES disables it. Since the tabs have the same information as the
+# navigation tree you can set this option to NO if you already set
+# GENERATE_TREEVIEW to YES.
+
+DISABLE_INDEX = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information.
+# If the tag value is set to YES, a side panel will be generated
+# containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
+# Windows users are probably better off using the HTML help feature.
+# Since the tree basically has the same information as the tab index you
+# could consider to set DISABLE_INDEX to NO when enabling this option.
+
+GENERATE_TREEVIEW = NO
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
+# (range [0,1..20]) that doxygen will group on one line in the generated HTML
+# documentation. Note that a value of 0 will completely suppress the enum
+# values from appearing in the overview section.
+
+ENUM_VALUES_PER_LINE = 4
+
+# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories,
+# and Class Hierarchy pages using a tree view instead of an ordered list.
+
+USE_INLINE_TREES = NO
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
+# is shown.
+
+TREEVIEW_WIDTH = 250
+
+# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
+# links to external symbols imported via tag files in a separate window.
+
+EXT_LINKS_IN_WINDOW = NO
+
+# Use this tag to change the font size of Latex formulas included
+# as images in the HTML documentation. The default is 10. Note that
+# when you change the font size after a successful doxygen run you need
+# to manually remove any form_*.png images from the HTML output directory
+# to force them to be regenerated.
+
+FORMULA_FONTSIZE = 10
+
+# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are
+# not supported properly for IE 6.0, but are supported on all modern browsers.
+# Note that when changing this option you need to delete any form_*.png files
+# in the HTML output before the changes have effect.
+
+FORMULA_TRANSPARENT = YES
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
+# (see http://www.mathjax.org) which uses client side Javascript for the
+# rendering instead of using prerendered bitmaps. Use this if you do not
+# have LaTeX installed or if you want to formulas look prettier in the HTML
+# output. When enabled you may also need to install MathJax separately and
+# configure the path to it using the MATHJAX_RELPATH option.
+
+USE_MATHJAX = NO
+
+# When MathJax is enabled you need to specify the location relative to the
+# HTML output directory using the MATHJAX_RELPATH option. The destination
+# directory should contain the MathJax.js script. For instance, if the mathjax
+# directory is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to
+# the MathJax Content Delivery Network so you can quickly see the result without
+# installing MathJax.
+# However, it is strongly recommended to install a local
+# copy of MathJax from http://www.mathjax.org before deployment.
+
+MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
+# names that should be enabled during MathJax rendering.
+
+MATHJAX_EXTENSIONS =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box
+# for the HTML output. The underlying search engine uses javascript
+# and DHTML and should work on any modern browser. Note that when using
+# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
+# (GENERATE_DOCSET) there is already a search function so this one should
+# typically be disabled. For large projects the javascript based search engine
+# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
+
+SEARCHENGINE = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a PHP enabled web server instead of at the web client
+# using Javascript. Doxygen will generate the search PHP script and index
+# file to put on the web server. The advantage of the server
+# based approach is that it scales better to large projects and allows
+# full text search. The disadvantages are that it is more difficult to setup
+# and does not have live searching capabilities.
+
+SERVER_BASED_SEARCH = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
+# generate Latex output.
+
+GENERATE_LATEX = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked. If left blank `latex' will be used as the default command name.
+# Note that when enabling USE_PDFLATEX this option is only used for
+# generating bitmaps for formulas in the HTML output, but not in the
+# Makefile that is written to the output directory.
+
+LATEX_CMD_NAME = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
+# default command name.
+
+MAKEINDEX_CMD_NAME = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
+# LaTeX documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_LATEX = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used
+# by the printer. Possible values are: a4, letter, legal and
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE = a4
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
+# the generated latex document. The header should contain everything until
+# the first chapter. If it is left blank doxygen will generate a
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
+# the generated latex document. The footer should contain everything after
+# the last chapter. If it is left blank doxygen will generate a
+# standard footer. Notice: only use this tag if you know what you are doing!
+
+LATEX_FOOTER =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will
+# contain links (just like the HTML output) instead of page references
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS = YES
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
+# plain latex in the generated Makefile. Set this option to YES to get a
+# higher quality PDF documentation.
+
+USE_PDFLATEX = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
+# command to the generated LaTeX files. This will instruct LaTeX to keep
+# running if errors occur, instead of asking the user for help.
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not
+# include the index chapters (such as File Index, Compound Index, etc.)
+# in the output.
+
+LATEX_HIDE_INDICES = NO
+
+# If LATEX_SOURCE_CODE is set to YES then doxygen will include
+# source code with syntax highlighting in the LaTeX output.
+# Note that which sources are shown also depends on other settings
+# such as SOURCE_BROWSER.
+
+LATEX_SOURCE_CODE = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
+# http://en.wikipedia.org/wiki/BibTeX for more info.
+
+LATEX_BIB_STYLE = plain
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
+# The RTF output is optimized for Word 97 and may not look very pretty with
+# other RTF readers or editors.
+
+GENERATE_RTF = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
+# RTF documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_RTF = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
+# will contain hyperlink fields. The RTF file will
+# contain links (just like the HTML output) instead of page references.
+# This makes the output suitable for online browsing using WORD or other
+# programs which support those fields.
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS = NO
+
+# Load style sheet definitions from file. Syntax is similar to doxygen's
+# config file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE =
+
+# Set optional variables used in the generation of an rtf document.
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
+# generate man pages
+
+GENERATE_MAN = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT = man
+
+# The MAN_EXTENSION tag determines the extension that is added to
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
+# then it will generate one additional man file for each entity
+# documented in the real man page(s). These additional files
+# only source the real man page, but without them the man command
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will
+# generate an XML file that captures the structure of
+# the code including all documentation.
+
+GENERATE_XML = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_SCHEMA =
+
+# The XML_DTD tag can be used to specify an XML DTD,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_DTD =
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
+# dump the program listings (including syntax highlighting
+# and cross-referencing information) to the XML output. Note that
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
+# generate an AutoGen Definitions (see autogen.sf.net) file
+# that captures the structure of the code including all
+# documentation. Note that this feature is still experimental
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will
+# generate a Perl module file that captures the structure of
+# the code including all documentation. Note that this
+# feature is still experimental and incomplete at the
+# moment.
+
+GENERATE_PERLMOD = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader.
+# This is useful
+# if you want to understand what is going on.
+# On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY = YES
+
+# The names of the make variables in the generated doxyrules.make file
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
+# This is useful so different doxyrules.make files included by the same
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
+# evaluate all C-preprocessor directives found in the sources and include
+# files.
+
+ENABLE_PREPROCESSING = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
+# names in the source code. If set to NO (the default) only conditional
+# compilation will be performed. Macro expansion can be done in a controlled
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
+# then the macro expansion is limited to the macros specified with the
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
+# pointed to by INCLUDE_PATH will be searched when a #include is found.
+
+SEARCH_INCLUDES = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by
+# the preprocessor.
+
+INCLUDE_PATH =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will
+# be used.
+
+INCLUDE_FILE_PATTERNS =
+
+# The PREDEFINED tag can be used to specify one or more macro names that
+# are defined before the preprocessor is started (similar to the -D option of
+# gcc). The argument of the tag is a list of macros of the form: name
+# or name=definition (no spaces). If the definition and the = are
+# omitted =1 is assumed. To prevent a macro definition from being
+# undefined via #undef or recursively expanded use the := operator
+# instead of the = operator.
+
+PREDEFINED =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
+# Use the PREDEFINED tag if you want to use a different macro definition that
+# overrules the definition found in the source code.
+
+EXPAND_AS_DEFINED =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all references to function-like macros
+# that are alone on a line, have an all uppercase name, and do not end with a
+# semicolon, because these will confuse the parser if not removed.
+
+SKIP_FUNCTION_MACROS = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles. For each
+# tag file the location of the external documentation should be added. The
+# format of a tag file without this location is as follows:
+#
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+#
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths
+# or URLs. Note that each tag file must have a unique name (where the name does
+# NOT include the path). If a tag file is not located in the directory in which
+# doxygen is run, you must also specify the path to the tagfile here.
+
+TAGFILES =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE =
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed
+# in the class index. If set to NO only the inherited external classes
+# will be listed.
+
+ALLEXTERNALS = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will
+# be listed.
+
+EXTERNAL_GROUPS = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# or super classes. Setting the tag to NO turns the diagrams off. Note that
+# this option also works with HAVE_DOT disabled, but it is recommended to
+# install and use dot, since it yields more powerful graphs.
+
+CLASS_DIAGRAMS = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see
+# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
+# documentation. The MSCGEN_PATH tag allows you to specify the directory where
+# the mscgen tool resides. If left empty the tool is assumed to be found in the
+# default search path.
+
+MSCGEN_PATH =
+
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz, a graph visualization
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT = NO
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
+# allowed to run in parallel. When set to 0 (the default) doxygen will
+# base this on the number of processors available in the system. You can set it
+# explicitly to a value larger than 0 to get control over the balance
+# between CPU load and processing speed.
+
+DOT_NUM_THREADS = 0
+
+# By default doxygen will use the Helvetica font for all dot files that
+# doxygen generates. When you want a differently looking font you can specify
+# the font name using DOT_FONTNAME. You need to make sure dot is able to find
+# the font, which can be done by putting it in a standard location or by setting
+# the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
+# directory containing the font.
+
+DOT_FONTNAME = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
+# The default size is 10pt.
+
+DOT_FONTSIZE = 10
+
+# By default doxygen will tell dot to use the Helvetica font.
+# If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
+# set the path where dot can find it.
+
+DOT_FONTPATH =
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
+# CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect implementation dependencies (inheritance, containment, and
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+
+UML_LOOK = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside
+# the class node. If there are many fields or methods and many nodes the
+# graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
+# threshold limits the number of items for each type to make the size more
+# managable. Set this to 0 for no limit. Note that the threshold may be
+# exceeded by 50% before the limit is enforced.
+
+UML_LIMIT_NUM_FIELDS = 10
+
+# If set to YES, the inheritance and collaboration graphs will show the
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
+# tags are set to YES then doxygen will generate a graph for each documented
+# file showing the direct and indirect include dependencies of the file with
+# other documented files.
+
+INCLUDE_GRAPH = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
+# documented header file showing the documented files that directly or
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH = YES
+
+# If the CALL_GRAPH and HAVE_DOT options are set to YES then
+# doxygen will generate a call dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable call graphs
+# for selected functions only using the \callgraph command.
+
+CALL_GRAPH = NO
+
+# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
+# doxygen will generate a caller dependency graph for every global function
+# or class method. Note that enabling this option will significantly increase
+# the time of a run. So in most cases it will be better to enable caller
+# graphs for selected functions only using the \callergraph command.
+
+CALLER_GRAPH = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
+# will generate a graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
+# then doxygen will show the dependencies a directory has on other directories
+# in a graphical way. The dependency relations are determined by the #include
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. Possible values are svg, png, jpg, or gif.
+# If left blank png will be used. If you choose svg you need to set
+# HTML_FILE_EXTENSION to xhtml in order to make the SVG files
+# visible in IE 9+ (other browsers do not have this requirement).
+
+DOT_IMAGE_FORMAT = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+# Note that this requires a modern browser other than Internet Explorer.
+# Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
+# need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
+# visible. Older versions of IE do not have SVG support.
+
+INTERACTIVE_SVG = NO
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the
+# \dotfile command).
+
+DOTFILE_DIRS =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the
+# \mscfile command).
+
+MSCFILE_DIRS =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
+# nodes that will be shown in the graph. If the number of nodes in a graph
+# becomes larger than this value, doxygen will truncate the graph, which is
+# visualized by representing a node as a red box. Note that doxygen if the
+# number of direct children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not
+# seem to support this out of the box. Warning: Depending on the platform used,
+# enabling this option may lead to badly anti-aliased labels on the edges of
+# a graph (i.e. they become hard to read).
+
+DOT_TRANSPARENT = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10)
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS = NO
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
+# generate a legend page explaining the meaning of the various boxes and
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
+# remove the intermediate dot files that are used to generate
+# the various graphs.
+
+DOT_CLEANUP = YES
--- /dev/null
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
--- /dev/null
+include common.mk
+
+OBJECTS := libthreads.o schedule.o model.o threads.o librace.o action.o \
+ nodestack.o clockvector.o main.o snapshot-interface.o cyclegraph.o \
+ datarace.o impatomic.o cmodelint.o \
+ snapshot.o malloc.o mymemory.o common.o mutex.o promise.o conditionvariable.o \
+ context.o scanalysis.o execution.o plugins.o libannotate.o
+
+CPPFLAGS += -Iinclude -I.
+LDFLAGS := -ldl -lrt -rdynamic
+SHARED := -shared
+
+# Mac OSX options
+ifeq ($(UNAME), Darwin)
+LDFLAGS := -ldl
+SHARED := -Wl,-undefined,dynamic_lookup -dynamiclib
+endif
+
+TESTS_DIR := test
+
+MARKDOWN := doc/Markdown/Markdown.pl
+
+all: $(LIB_SO) tests README.html
+
+debug: CPPFLAGS += -DCONFIG_DEBUG
+debug: all
+
+PHONY += docs
+docs: *.c *.cc *.h README.html
+ doxygen
+
+README.html: README.md
+ $(MARKDOWN) $< > $@
+
+$(LIB_SO): $(OBJECTS)
+ $(CXX) $(SHARED) -o $(LIB_SO) $+ $(LDFLAGS)
+
+malloc.o: malloc.c
+ $(CC) -fPIC -c malloc.c -DMSPACES -DONLY_MSPACES -DHAVE_MMAP=0 $(CPPFLAGS) -Wno-unused-variable
+
+%.o: %.cc
+ $(CXX) -MMD -MF .$@.d -fPIC -c $< $(CPPFLAGS)
+
+%.pdf: %.dot
+ dot -Tpdf $< -o $@
+
+-include $(OBJECTS:%=.%.d)
+
+PHONY += clean
+clean:
+ rm -f *.o *.so .*.d *.pdf *.dot
+ $(MAKE) -C $(TESTS_DIR) clean
+
+PHONY += mrclean
+mrclean: clean
+ rm -rf docs
+
+PHONY += tags
+tags:
+ ctags -R
+
+PHONY += tests
+tests: $(LIB_SO)
+ $(MAKE) -C $(TESTS_DIR)
+
+BENCH_DIR := benchmarks
+
+PHONY += benchmarks
+benchmarks: $(LIB_SO)
+ @if ! test -d $(BENCH_DIR); then \
+ echo "Directory $(BENCH_DIR) does not exist" && \
+ echo "Please clone the benchmarks repository" && \
+ echo && \
+ exit 1; \
+ fi
+ $(MAKE) -C $(BENCH_DIR)
+
+PHONY += pdfs
+pdfs: $(patsubst %.dot,%.pdf,$(wildcard *.dot))
+
+.PHONY: $(PHONY)
+
+# A 1-inch margin PDF generated by 'pandoc'
+%.pdf: %.md
+ pandoc -o $@ $< -V header-includes='\usepackage[margin=1in]{geometry}'
--- /dev/null
+CDSChecker: A Model Checker for C11 and C++11 Atomics
+=====================================================
+
+CDSChecker is a model checker for C11/C++11 which exhaustively explores the
+behaviors of code under the C/C++ memory model. It uses partial order reduction
+as well as a few other novel techniques to eliminate time spent on redundant
+execution behaviors and to significantly shrink the state space. The model
+checking algorithm is described in more detail in this paper (published in
+OOPSLA '13):
+
+> <http://demsky.eecs.uci.edu/publications/c11modelcheck.pdf>
+
+It is designed to support unit tests on concurrent data structure written using
+C/C++ atomics.
+
+CDSChecker is constructed as a dynamically-linked shared library which
+implements the C and C++ atomic types and portions of the other thread-support
+libraries of C/C++ (e.g., std::atomic, std::mutex, etc.). Notably, we only
+support the C version of threads (i.e., `thrd_t` and similar, from `<threads.h>`),
+because C++ threads require features which are only available to a C++11
+compiler (and we want to support others, at least for now).
+
+CDSChecker should compile on Linux and Mac OSX with no dependencies and has been
+tested with LLVM (clang/clang++) and GCC. It likely can be ported to other \*NIX
+flavors. We have not attempted to port to Windows.
+
+
+Getting Started
+---------------
+
+If you haven't done so already, you may download CDSChecker using
+[git](http://git-scm.com/):
+
+ git clone git://demsky.eecs.uci.edu/model-checker.git
+
+Source code can also be downloaded via the snapshot links on Gitweb (found in
+the __See Also__ section).
+
+Get the benchmarks (not required; distributed separately), placing them as a
+subdirectory under the `model-checker` directory:
+
+ cd model-checker
+ git clone git://demsky.eecs.uci.edu/model-checker-benchmarks.git benchmarks
+
+Compile the model checker:
+
+ make
+
+Compile the benchmarks:
+
+ make benchmarks
+
+Run a simple example (the `run.sh` script does some very minimal processing for
+you):
+
+ ./run.sh test/userprog.o
+
+To see the help message on how to run CDSChecker, execute:
+
+ ./run.sh -h
+
+
+Useful Options
+--------------
+
+`-m num`
+
+ > Controls the liveness of the memory system. Note that multithreaded programs
+ > often rely on memory liveness for termination, so this parameter is
+ > necessary for such programs.
+ >
+ > Liveness is controlled by `num`: the number of times a load is allowed to
+ > see the same store when a newer store exists---one that is ordered later in
+ > the modification order.
+
+`-y`
+
+ > Turns on CHESS-like yield-based fairness support (requires `thrd_yield()`
+ > instrumentation in test program).
+
+`-f num`
+
+ > Turns on alternative fairness support (less desirable than `-y`). A
+ > necessary alternative for some programs that do not support yield-based
+ > fairness properly.
+
+`-v`
+
+ > Verbose: show all executions and not just buggy ones.
+
+`-s num`
+
+ > Constrain how long we will run to wait for a future value past when it is
+ > expected
+
+`-u num`
+
+ > Value to provide to atomics loads from uninitialized memory locations. The
+ > default is 0, but this may cause some programs to throw exceptions
+ > (segfault) before the model checker prints a trace.
+
+Suggested options:
+
+> -m 2 -y
+
+or
+
+> -m 2 -f 10
+
+
+Benchmarks
+-------------------
+
+Many simple tests are located in the `tests/` directory. You may also want to
+try the larger benchmarks (distributed separately), which can be placed under
+the `benchmarks/` directory. After building CDSChecker, you can build and run
+the benchmarks as follows:
+
+> make benchmarks
+> cd benchmarks
+>
+> # run barrier test with fairness/memory liveness
+> ./run.sh barrier/barrier -y -m 2
+>
+> # Linux reader/write lock test with fairness/memory liveness
+> ./run.sh linuxrwlocks/linuxrwlocks -y -m 2
+>
+> # run all benchmarks and provide timing results
+> ./bench.sh
+
+
+Running your own code
+---------------------
+
+You likely want to test your own code, not just our simple tests. To do so, you
+need to perform a few steps.
+
+First, because CDSChecker executes your program dozens (if not hundreds or
+thousands) of times, you will have the most success if your code is written as a
+unit test and not as a full-blown program.
+
+Second, because CDSChecker must be able to manage your program for you, your
+program should declare its main entry point as `user_main(int, char**)` rather
+than `main(int, char**)`.
+
+Third, test programs must use the standard C11/C++11 library headers (see below
+for supported APIs) and must compile against the versions provided in
+CDSChecker's `include/` directory. Notably, we only support C11 thread syntax
+(`thrd_t`, etc. from `<thread.h>`).
+
+Test programs may also use our included happens-before race detector by
+including <librace.h> and utilizing the appropriate functions
+(`store_{8,16,32,64}()` and `load_{8,16,32,64}()`) for storing/loading data
+to/from non-atomic shared memory.
+
+CDSChecker can also check boolean assertions in your test programs. Just
+include `<model-assert.h>` and use the `MODEL_ASSERT()` macro in your test program.
+CDSChecker will report a bug in any possible execution in which the argument to
+`MODEL_ASSERT()` evaluates to false (that is, 0).
+
+Test programs should be compiled against our shared library (libmodel.so) using
+the headers in the `include/` directory. Then the shared library must be made
+available to the dynamic linker, using the `LD_LIBRARY_PATH` environment
+variable, for instance.
+
+
+### Supported C11/C++11 APIs ###
+
+To model-check multithreaded code properly, CDSChecker needs to instrument any
+concurrency-related API calls made in your code. Currently, we support parts of
+the following thread-support libraries. The C versions can be used in either C
+or C++.
+
+* `<atomic>`, `<cstdatomic>`, `<stdatomic.h>`
+* `<condition_variable>`
+* `<mutex>`
+* `<threads.h>`
+
+Because we want to extend support to legacy (i.e., non-C++11) compilers, we do
+not support some new C++11 features that can't be implemented in C++03 (e.g.,
+C++ `<thread>`).
+
+Reading an execution trace
+--------------------------
+
+When CDSChecker detects a bug in your program (or when run with the `--verbose`
+flag), it prints the output of the program run (STDOUT) along with some summary
+trace information for the execution in question. The trace is given as a
+sequence of lines, where each line represents an operation in the execution
+trace. These lines are ordered by the order in which they were run by CDSChecker
+(i.e., the "execution order"), which does not necessarily align with the "order"
+of the values observed (i.e., the modification order or the reads-from
+relation).
+
+The following list describes each of the columns in the execution trace output:
+
+ * \#: The sequence number within the execution. That is, sequence number "9"
+ means the operation was the 9th operation executed by CDSChecker. Note that
+ this represents the execution order, not necessarily any other order (e.g.,
+ modification order or reads-from).
+
+ * t: The thread number
+
+ * Action type: The type of operation performed
+
+ * MO: The memory-order for this operation (i.e., `memory_order_XXX`, where `XXX` is
+ `relaxed`, `release`, `acquire`, `rel_acq`, or `seq_cst`)
+
+ * Location: The memory location on which this operation is operating. This is
+ well-defined for atomic write/read/RMW, but other operations are subject to
+ CDSChecker implementation details.
+
+ * Value: For reads/writes/RMW, the value returned by the operation. Note that
+ for RMW, this is the value that is *read*, not the value that was *written*.
+ For other operations, 'value' may have some CDSChecker-internal meaning, or
+ it may simply be a don't-care (such as `0xdeadbeef`).
+
+ * Rf: For reads, the sequence number of the operation from which it reads.
+ [Note: If the execution is a partial, infeasible trace (labeled INFEASIBLE),
+ as printed during `--verbose` execution, reads may not be resolved and so may
+ have Rf=? or Rf=Px, where x is a promised future value.]
+
+ * CV: The clock vector, encapsulating the happens-before relation (see our
+ paper, or the C/C++ memory model itself). We use a Lamport-style clock vector
+ similar to [1]. The "clock" is just the sequence number (#). The clock vector
+ can be read as follows:
+
+ Each entry is indexed as CV[i], where
+
+ i = 0, 1, 2, ..., <number of threads>
+
+ So for any thread i, we say CV[i] is the sequence number of the most recent
+ operation in thread i such that operation i happens-before this operation.
+ Notably, thread 0 is reserved as a dummy thread for certain CDSChecker
+ operations.
+
+See the following example trace:
+
+ ------------------------------------------------------------------------------------
+ # t Action type MO Location Value Rf CV
+ ------------------------------------------------------------------------------------
+ 1 1 thread start seq_cst 0x7f68ff11e7c0 0xdeadbeef ( 0, 1)
+ 2 1 init atomic relaxed 0x601068 0 ( 0, 2)
+ 3 1 init atomic relaxed 0x60106c 0 ( 0, 3)
+ 4 1 thread create seq_cst 0x7f68fe51c710 0x7f68fe51c6e0 ( 0, 4)
+ 5 2 thread start seq_cst 0x7f68ff11ebc0 0xdeadbeef ( 0, 4, 5)
+ 6 2 atomic read relaxed 0x60106c 0 3 ( 0, 4, 6)
+ 7 1 thread create seq_cst 0x7f68fe51c720 0x7f68fe51c6e0 ( 0, 7)
+ 8 3 thread start seq_cst 0x7f68ff11efc0 0xdeadbeef ( 0, 7, 0, 8)
+ 9 2 atomic write relaxed 0x601068 0 ( 0, 4, 9)
+ 10 3 atomic read relaxed 0x601068 0 2 ( 0, 7, 0, 10)
+ 11 2 thread finish seq_cst 0x7f68ff11ebc0 0xdeadbeef ( 0, 4, 11)
+ 12 3 atomic write relaxed 0x60106c 0x2a ( 0, 7, 0, 12)
+ 13 1 thread join seq_cst 0x7f68ff11ebc0 0x2 ( 0, 13, 11)
+ 14 3 thread finish seq_cst 0x7f68ff11efc0 0xdeadbeef ( 0, 7, 0, 14)
+ 15 1 thread join seq_cst 0x7f68ff11efc0 0x3 ( 0, 15, 11, 14)
+ 16 1 thread finish seq_cst 0x7f68ff11e7c0 0xdeadbeef ( 0, 16, 11, 14)
+ HASH 4073708854
+ ------------------------------------------------------------------------------------
+
+Now consider, for example, operation 10:
+
+This is the 10th operation in the execution order. It is an atomic read-relaxed
+operation performed by thread 3 at memory address `0x601068`. It reads the value
+"0", which was written by the 2nd operation in the execution order. Its clock
+vector consists of the following values:
+
+ CV[0] = 0, CV[1] = 7, CV[2] = 0, CV[3] = 10
+
+End of Execution Summary
+------------------------
+
+CDSChecker prints summary statistics at the end of each execution. These
+summaries are based off of a few different properties of an execution, which we
+will break down here:
+
+* An _infeasible_ execution is an execution which is not consistent with the
+ memory model. Such an execution can be considered overhead for the
+ model-checker, since it should never appear in practice.
+
+* A _buggy_ execution is an execution in which CDSChecker has found a real
+ bug: a data race, a deadlock, failure of a user-provided assertion, or an
+ uninitialized load, for instance. CDSChecker will only report bugs in feasible
+ executions.
+
+* A _redundant_ execution is a feasible execution that is exploring the same
+ state space explored by a previous feasible execution. Such exploration is
+ another instance of overhead, so CDSChecker terminates these executions as
+ soon as they are detected. CDSChecker is mostly able to avoid such executions
+ but may encounter them if a fairness option is enabled.
+
+Now, we can examine the end-of-execution summary of one test program:
+
+ $ ./run.sh test/rmwprog.o
+ + test/rmwprog.o
+ ******* Model-checking complete: *******
+ Number of complete, bug-free executions: 6
+ Number of redundant executions: 0
+ Number of buggy executions: 0
+ Number of infeasible executions: 29
+ Total executions: 35
+
+* _Number of complete, bug-free executions:_ these are feasible, non-buggy, and
+ non-redundant executions. They each represent different, legal behaviors you
+ can expect to see in practice.
+
+* _Number of redundant executions:_ these are feasible but redundant executions
+ that were terminated as soon as CDSChecker noticed the redundancy.
+
+* _Number of buggy executions:_ these are feasible, buggy executions. These are
+ the trouble spots where your program is triggering a bug or assertion.
+ Ideally, this number should be 0.
+
+* _Number of infeasible executions:_ these are infeasible executions,
+ representing some of the overhead of model-checking.
+
+* _Total executions:_ the total number of executions explored by CDSChecker.
+ Should be the sum of the above categories, since they are mutually exclusive.
+
+
+Other Notes and Pitfalls
+------------------------
+
+* Many programs require some form of fairness in order to terminate in a finite
+ amount of time. CDSChecker supports the `-y num` and `-f num` flags for these
+ cases. The `-y` option (yield-based fairness) is preferable, but it requires
+ careful usage of yields (i.e., `thrd_yield()`) in the test program. For
+ programs without proper `thrd_yield()`, you may consider using `-f` instead.
+
+* Deadlock detection: CDSChecker can detect deadlocks. For instance, try the
+ following test program.
+
+ > ./run.sh test/deadlock.o
+
+ Deadlock detection currently detects when a thread is about to step into a
+ deadlock, without actually including the final step in the trace. But you can
+ examine the program to see the next step.
+
+* CDSChecker has to speculatively explore many execution behaviors due to the
+ relaxed memory model, and many of these turn out to be infeasible (that is,
+ they cannot be legally produced by the memory model). CDSChecker discards
+ these executions as soon as it identifies them (see the "Number of infeasible
+ executions" statistic); however, the speculation can occasionally cause
+ CDSChecker to hit unexpected parts of the unit test program (causing a
+ division by 0, for instance). In such programs, you might consider running
+ CDSChecker with the `-u num` option.
+
+* Related to the previous point, CDSChecker may report more than one bug for a
+ particular candidate execution. This is because some bugs may not be
+ reportable until CDSChecker has explored more of the program, and in the
+ time between initial discovery and final assessment of the bug, CDSChecker may
+ discover another bug.
+
+* Data races may be reported as multiple bugs, one for each byte-address of the
+ data race in question. See, for example, this run:
+
+ $ ./run.sh test/releaseseq.o
+ ...
+ Bug report: 4 bugs detected
+ [BUG] Data race detected @ address 0x601078:
+ Access 1: write in thread 2 @ clock 4
+ Access 2: read in thread 3 @ clock 9
+ [BUG] Data race detected @ address 0x601079:
+ Access 1: write in thread 2 @ clock 4
+ Access 2: read in thread 3 @ clock 9
+ [BUG] Data race detected @ address 0x60107a:
+ Access 1: write in thread 2 @ clock 4
+ Access 2: read in thread 3 @ clock 9
+ [BUG] Data race detected @ address 0x60107b:
+ Access 1: write in thread 2 @ clock 4
+ Access 2: read in thread 3 @ clock 9
+
+
+See Also
+--------
+
+The CDSChecker project page:
+
+> <http://demsky.eecs.uci.edu/c11modelchecker.html>
+
+The CDSChecker source and accompanying benchmarks on Gitweb:
+
+> <http://demsky.eecs.uci.edu/git/?p=model-checker.git>
+>
+> <http://demsky.eecs.uci.edu/git/?p=model-checker-benchmarks.git>
+
+
+Contact
+-------
+
+Please feel free to contact us for more information. Bug reports are welcome,
+and we are happy to hear from our users. We are also very interested to know if
+CDSChecker catches bugs in your programs.
+
+Contact Brian Norris at <banorris@uci.edu> or Brian Demsky at <bdemsky@uci.edu>.
+
+
+Copyright
+---------
+
+Copyright © 2013 Regents of the University of California. All rights reserved.
+
+CDSChecker is distributed under the GPL v2. See the LICENSE file for details.
+
+
+References
+----------
+
+[1] L. Lamport. Time, clocks, and the ordering of events in a distributed
+ system. CACM, 21(7):558-565, July 1978.
--- /dev/null
+#include <stdio.h>
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+#include <stdlib.h>
+
+#include "model.h"
+#include "action.h"
+#include "clockvector.h"
+#include "common.h"
+#include "threads-model.h"
+#include "nodestack.h"
+
+#define ACTION_INITIAL_CLOCK 0
+
+/** @brief A special value to represent a successful trylock */
+#define VALUE_TRYSUCCESS 1
+
+/** @brief A special value to represent a failed trylock */
+#define VALUE_TRYFAILED 0
+
+/**
+ * @brief Construct a new ModelAction
+ *
+ * @param type The type of action
+ * @param order The memory order of this action. A "don't care" for non-ATOMIC
+ * actions (e.g., THREAD_* or MODEL_* actions).
+ * @param loc The location that this action acts upon
+ * @param value (optional) A value associated with the action (e.g., the value
+ * read or written). Defaults to a given macro constant, for debugging purposes.
+ * @param thread (optional) The Thread in which this action occurred. If NULL
+ * (default), then a Thread is assigned according to the scheduler.
+ */
+ModelAction::ModelAction(action_type_t type, memory_order order, void *loc,
+ uint64_t value, Thread *thread) :
+ type(type),
+ order(order),
+ location(loc),
+ value(value),
+ reads_from(NULL),
+ reads_from_promise(NULL),
+ last_fence_release(NULL),
+ node(NULL),
+ seq_number(ACTION_INITIAL_CLOCK),
+ cv(NULL),
+ sleep_flag(false)
+{
+ /* References to NULL atomic variables can end up here */
+ ASSERT(loc || type == ATOMIC_FENCE || type == MODEL_FIXUP_RELSEQ);
+
+ Thread *t = thread ? thread : thread_current();
+ this->tid = t->get_id();
+}
+
+/** @brief ModelAction destructor */
+ModelAction::~ModelAction()
+{
+ /**
+ * We can't free the clock vector:
+ * Clock vectors are snapshotting state. When we delete model actions,
+ * they are at the end of the node list and have invalid old clock
+ * vectors which have already been rolled back to an unallocated state.
+ */
+
+ /*
+ if (cv)
+ delete cv; */
+}
+
+void ModelAction::copy_from_new(ModelAction *newaction)
+{
+ seq_number = newaction->seq_number;
+}
+
+void ModelAction::set_seq_number(modelclock_t num)
+{
+ /* ATOMIC_UNINIT actions should never have non-zero clock */
+ ASSERT(!is_uninitialized());
+ ASSERT(seq_number == ACTION_INITIAL_CLOCK);
+ seq_number = num;
+}
+
+bool ModelAction::is_thread_start() const
+{
+ return type == THREAD_START;
+}
+
+bool ModelAction::is_thread_join() const
+{
+ return type == THREAD_JOIN;
+}
+
+bool ModelAction::is_relseq_fixup() const
+{
+ return type == MODEL_FIXUP_RELSEQ;
+}
+
+bool ModelAction::is_mutex_op() const
+{
+ return type == ATOMIC_LOCK || type == ATOMIC_TRYLOCK || type == ATOMIC_UNLOCK || type == ATOMIC_WAIT || type == ATOMIC_NOTIFY_ONE || type == ATOMIC_NOTIFY_ALL;
+}
+
+bool ModelAction::is_lock() const
+{
+ return type == ATOMIC_LOCK;
+}
+
+bool ModelAction::is_wait() const {
+ return type == ATOMIC_WAIT;
+}
+
+bool ModelAction::is_notify() const {
+ return type == ATOMIC_NOTIFY_ONE || type == ATOMIC_NOTIFY_ALL;
+}
+
+bool ModelAction::is_notify_one() const {
+ return type == ATOMIC_NOTIFY_ONE;
+}
+
+bool ModelAction::is_unlock() const
+{
+ return type == ATOMIC_UNLOCK;
+}
+
+bool ModelAction::is_trylock() const
+{
+ return type == ATOMIC_TRYLOCK;
+}
+
+bool ModelAction::is_success_lock() const
+{
+ return type == ATOMIC_LOCK || (type == ATOMIC_TRYLOCK && value == VALUE_TRYSUCCESS);
+}
+
+bool ModelAction::is_failed_trylock() const
+{
+ return (type == ATOMIC_TRYLOCK && value == VALUE_TRYFAILED);
+}
+
+/** @return True if this operation is performed on a C/C++ atomic variable */
+bool ModelAction::is_atomic_var() const
+{
+ return is_read() || could_be_write();
+}
+
+bool ModelAction::is_uninitialized() const
+{
+ return type == ATOMIC_UNINIT;
+}
+
+bool ModelAction::is_read() const
+{
+ return type == ATOMIC_READ || type == ATOMIC_RMWR || type == ATOMIC_RMW;
+}
+
+bool ModelAction::is_write() const
+{
+ return type == ATOMIC_WRITE || type == ATOMIC_RMW || type == ATOMIC_INIT || type == ATOMIC_UNINIT;
+}
+
+bool ModelAction::could_be_write() const
+{
+ return is_write() || is_rmwr();
+}
+
+bool ModelAction::is_yield() const
+{
+ return type == THREAD_YIELD;
+}
+
+bool ModelAction::is_rmwr() const
+{
+ return type == ATOMIC_RMWR;
+}
+
+bool ModelAction::is_rmw() const
+{
+ return type == ATOMIC_RMW;
+}
+
+bool ModelAction::is_rmwc() const
+{
+ return type == ATOMIC_RMWC;
+}
+
+bool ModelAction::is_fence() const
+{
+ return type == ATOMIC_FENCE;
+}
+
+bool ModelAction::is_initialization() const
+{
+ return type == ATOMIC_INIT;
+}
+
+bool ModelAction::is_annotation() const
+{
+ return type == ATOMIC_ANNOTATION;
+}
+
+bool ModelAction::is_relaxed() const
+{
+ return order == std::memory_order_relaxed;
+}
+
+bool ModelAction::is_acquire() const
+{
+ switch (order) {
+ case std::memory_order_acquire:
+ case std::memory_order_acq_rel:
+ case std::memory_order_seq_cst:
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool ModelAction::is_release() const
+{
+ switch (order) {
+ case std::memory_order_release:
+ case std::memory_order_acq_rel:
+ case std::memory_order_seq_cst:
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool ModelAction::is_seqcst() const
+{
+ return order == std::memory_order_seq_cst;
+}
+
+bool ModelAction::same_var(const ModelAction *act) const
+{
+ if (act->is_wait() || is_wait()) {
+ if (act->is_wait() && is_wait()) {
+ if (((void *)value) == ((void *)act->value))
+ return true;
+ } else if (is_wait()) {
+ if (((void *)value) == act->location)
+ return true;
+ } else if (act->is_wait()) {
+ if (location == ((void *)act->value))
+ return true;
+ }
+ }
+
+ return location == act->location;
+}
+
+bool ModelAction::same_thread(const ModelAction *act) const
+{
+ return tid == act->tid;
+}
+
+void ModelAction::copy_typeandorder(ModelAction * act)
+{
+ this->type = act->type;
+ this->order = act->order;
+}
+
+/**
+ * Get the Thread which is the operand of this action. This is only valid for
+ * THREAD_* operations (currently only for THREAD_CREATE and THREAD_JOIN). Note
+ * that this provides a central place for determining the conventions of Thread
+ * storage in ModelAction, where we generally aren't very type-safe (e.g., we
+ * store object references in a (void *) address.
+ *
+ * For THREAD_CREATE, this yields the Thread which is created.
+ * For THREAD_JOIN, this yields the Thread we are joining with.
+ *
+ * @return The Thread which this action acts on, if exists; otherwise NULL
+ */
+Thread * ModelAction::get_thread_operand() const
+{
+ if (type == THREAD_CREATE) {
+ /* THREAD_CREATE stores its (Thread *) in a thrd_t::priv */
+ thrd_t *thrd = (thrd_t *)get_location();
+ return thrd->priv;
+ } else if (type == THREAD_JOIN)
+ /* THREAD_JOIN uses (Thread *) for location */
+ return (Thread *)get_location();
+ else
+ return NULL;
+}
+
+/**
+ * @brief Convert the read portion of an RMW
+ *
+ * Changes an existing read part of an RMW action into either:
+ * -# a full RMW action in case of the completed write or
+ * -# a READ action in case a failed action.
+ *
+ * @todo If the memory_order changes, we may potentially need to update our
+ * clock vector.
+ *
+ * @param act The second half of the RMW (either RMWC or RMW)
+ */
+void ModelAction::process_rmw(ModelAction *act)
+{
+ this->order = act->order;
+ if (act->is_rmwc())
+ this->type = ATOMIC_READ;
+ else if (act->is_rmw()) {
+ this->type = ATOMIC_RMW;
+ this->value = act->value;
+ }
+}
+
+/**
+ * @brief Check if this action should be backtracked with another, due to
+ * potential synchronization
+ *
+ * The is_synchronizing method should only explore interleavings if:
+ * -# the operations are seq_cst and don't commute or
+ * -# the reordering may establish or break a synchronization relation.
+ *
+ * Other memory operations will be dealt with by using the reads_from relation.
+ *
+ * @param act The action to consider exploring a reordering
+ * @return True, if we have to explore a reordering; otherwise false
+ */
+bool ModelAction::could_synchronize_with(const ModelAction *act) const
+{
+ // Same thread can't be reordered
+ if (same_thread(act))
+ return false;
+
+ // Different locations commute
+ if (!same_var(act))
+ return false;
+
+ // Explore interleavings of seqcst writes/fences to guarantee total
+ // order of seq_cst operations that don't commute
+ if ((could_be_write() || act->could_be_write() || is_fence() || act->is_fence()) && is_seqcst() && act->is_seqcst())
+ return true;
+
+ // Explore synchronizing read/write pairs
+ if (is_acquire() && act->is_release() && is_read() && act->could_be_write())
+ return true;
+
+ // lock just released...we can grab lock
+ if ((is_lock() || is_trylock()) && (act->is_unlock() || act->is_wait()))
+ return true;
+
+ // lock just acquired...we can fail to grab lock
+ if (is_trylock() && act->is_success_lock())
+ return true;
+
+ // other thread stalling on lock...we can release lock
+ if (is_unlock() && (act->is_trylock() || act->is_lock()))
+ return true;
+
+ if (is_trylock() && (act->is_unlock() || act->is_wait()))
+ return true;
+
+ if (is_notify() && act->is_wait())
+ return true;
+
+ if (is_wait() && act->is_notify())
+ return true;
+
+ // Otherwise handle by reads_from relation
+ return false;
+}
+
+bool ModelAction::is_conflicting_lock(const ModelAction *act) const
+{
+ // Must be different threads to reorder
+ if (same_thread(act))
+ return false;
+
+ // Try to reorder a lock past a successful lock
+ if (act->is_success_lock())
+ return true;
+
+ // Try to push a successful trylock past an unlock
+ if (act->is_unlock() && is_trylock() && value == VALUE_TRYSUCCESS)
+ return true;
+
+ // Try to push a successful trylock past a wait
+ if (act->is_wait() && is_trylock() && value == VALUE_TRYSUCCESS)
+ return true;
+
+ return false;
+}
+
+/**
+ * Create a new clock vector for this action. Note that this function allows a
+ * user to clobber (and leak) a ModelAction's existing clock vector. A user
+ * should ensure that the vector has already either been rolled back
+ * (effectively "freed") or freed.
+ *
+ * @param parent A ModelAction from which to inherit a ClockVector
+ */
+void ModelAction::create_cv(const ModelAction *parent)
+{
+ if (parent)
+ cv = new ClockVector(parent->cv, this);
+ else
+ cv = new ClockVector(NULL, this);
+}
+
+void ModelAction::set_try_lock(bool obtainedlock)
+{
+ value = obtainedlock ? VALUE_TRYSUCCESS : VALUE_TRYFAILED;
+}
+
+/**
+ * @brief Get the value read by this load
+ *
+ * We differentiate this function from ModelAction::get_write_value and
+ * ModelAction::get_value for the purpose of RMW's, which may have both a
+ * 'read' and a 'write' value.
+ *
+ * Note: 'this' must be a load.
+ *
+ * @return The value read by this load
+ */
+uint64_t ModelAction::get_reads_from_value() const
+{
+ ASSERT(is_read());
+ if (reads_from)
+ return reads_from->get_write_value();
+ else if (reads_from_promise)
+ return reads_from_promise->get_value();
+ return VALUE_NONE; /* Only for new actions with no reads-from */
+}
+
+/**
+ * @brief Get the value written by this store
+ *
+ * We differentiate this function from ModelAction::get_reads_from_value and
+ * ModelAction::get_value for the purpose of RMW's, which may have both a
+ * 'read' and a 'write' value.
+ *
+ * Note: 'this' must be a store.
+ *
+ * @return The value written by this store
+ */
+uint64_t ModelAction::get_write_value() const
+{
+ ASSERT(is_write());
+ return value;
+}
+
+/**
+ * @brief Get the value returned by this action
+ *
+ * For atomic reads (including RMW), an operation returns the value it read.
+ * For atomic writes, an operation returns the value it wrote. For other
+ * operations, the return value varies (sometimes is a "don't care"), but the
+ * value is simply stored in the "value" field.
+ *
+ * @return This action's return value
+ */
+uint64_t ModelAction::get_return_value() const
+{
+ if (is_read())
+ return get_reads_from_value();
+ else if (is_write())
+ return get_write_value();
+ else
+ return value;
+}
+
+/** @return The Node associated with this ModelAction */
+Node * ModelAction::get_node() const
+{
+ /* UNINIT actions do not have a Node */
+ ASSERT(!is_uninitialized());
+ return node;
+}
+
+/**
+ * Update the model action's read_from action
+ * @param act The action to read from; should be a write
+ */
+void ModelAction::set_read_from(const ModelAction *act)
+{
+ ASSERT(act);
+ reads_from = act;
+ reads_from_promise = NULL;
+ if (act->is_uninitialized())
+ model->assert_bug("May read from uninitialized atomic:\n"
+ " action %d, thread %d, location %p (%s, %s)",
+ seq_number, id_to_int(tid), location,
+ get_type_str(), get_mo_str());
+}
+
+/**
+ * Set this action's read-from promise
+ * @param promise The promise to read from
+ */
+void ModelAction::set_read_from_promise(Promise *promise)
+{
+ ASSERT(is_read());
+ reads_from_promise = promise;
+ reads_from = NULL;
+}
+
+/**
+ * Synchronize the current thread with the thread corresponding to the
+ * ModelAction parameter.
+ * @param act The ModelAction to synchronize with
+ * @return True if this is a valid synchronization; false otherwise
+ */
+bool ModelAction::synchronize_with(const ModelAction *act)
+{
+ if (*this < *act)
+ return false;
+ cv->merge(act->cv);
+ return true;
+}
+
+bool ModelAction::has_synchronized_with(const ModelAction *act) const
+{
+ return cv->synchronized_since(act);
+}
+
+/**
+ * Check whether 'this' happens before act, according to the memory-model's
+ * happens before relation. This is checked via the ClockVector constructs.
+ * @return true if this action's thread has synchronized with act's thread
+ * since the execution of act, false otherwise.
+ */
+bool ModelAction::happens_before(const ModelAction *act) const
+{
+ return act->cv->synchronized_since(this);
+}
+
+const char * ModelAction::get_type_str() const
+{
+ switch (this->type) {
+ case MODEL_FIXUP_RELSEQ: return "relseq fixup";
+ case THREAD_CREATE: return "thread create";
+ case THREAD_START: return "thread start";
+ case THREAD_YIELD: return "thread yield";
+ case THREAD_JOIN: return "thread join";
+ case THREAD_FINISH: return "thread finish";
+ case ATOMIC_UNINIT: return "uninitialized";
+ case ATOMIC_READ: return "atomic read";
+ case ATOMIC_WRITE: return "atomic write";
+ case ATOMIC_RMW: return "atomic rmw";
+ case ATOMIC_FENCE: return "fence";
+ case ATOMIC_RMWR: return "atomic rmwr";
+ case ATOMIC_RMWC: return "atomic rmwc";
+ case ATOMIC_INIT: return "init atomic";
+ case ATOMIC_LOCK: return "lock";
+ case ATOMIC_UNLOCK: return "unlock";
+ case ATOMIC_TRYLOCK: return "trylock";
+ case ATOMIC_WAIT: return "wait";
+ case ATOMIC_NOTIFY_ONE: return "notify one";
+ case ATOMIC_NOTIFY_ALL: return "notify all";
+ case ATOMIC_ANNOTATION: return "atomic annotation";
+ default: return "unknown type";
+ };
+}
+
+const char * ModelAction::get_mo_str() const
+{
+ switch (this->order) {
+ case std::memory_order_relaxed: return "relaxed";
+ case std::memory_order_acquire: return "acquire";
+ case std::memory_order_release: return "release";
+ case std::memory_order_acq_rel: return "acq_rel";
+ case std::memory_order_seq_cst: return "seq_cst";
+ default: return "unknown";
+ }
+}
+
+/** @brief Print nicely-formatted info about this ModelAction */
+void ModelAction::print() const
+{
+ const char *type_str = get_type_str(), *mo_str = get_mo_str();
+
+ model_print("%-4d %-2d %-13s %7s %14p %-#18" PRIx64,
+ seq_number, id_to_int(tid), type_str, mo_str, location, get_return_value());
+ if (is_read()) {
+ if (reads_from)
+ model_print(" %-3d", reads_from->get_seq_number());
+ else if (reads_from_promise) {
+ int idx = reads_from_promise->get_index();
+ if (idx >= 0)
+ model_print(" P%-2d", idx);
+ else
+ model_print(" P? ");
+ } else
+ model_print(" ? ");
+ }
+ if (cv) {
+ if (is_read())
+ model_print(" ");
+ else
+ model_print(" ");
+ cv->print();
+ } else
+ model_print("\n");
+}
+
+/** @brief Get a (likely) unique hash for this ModelAction */
+unsigned int ModelAction::hash() const
+{
+ unsigned int hash = (unsigned int)this->type;
+ hash ^= ((unsigned int)this->order) << 3;
+ hash ^= seq_number << 5;
+ hash ^= id_to_int(tid) << 6;
+
+ if (is_read()) {
+ if (reads_from)
+ hash ^= reads_from->get_seq_number();
+ else if (reads_from_promise)
+ hash ^= reads_from_promise->get_index();
+ hash ^= get_reads_from_value();
+ }
+ return hash;
+}
+
+/**
+ * @brief Checks the NodeStack to see if a ModelAction is in our may-read-from set
+ * @param write The ModelAction to check for
+ * @return True if the ModelAction is found; false otherwise
+ */
+bool ModelAction::may_read_from(const ModelAction *write) const
+{
+ for (int i = 0; i < node->get_read_from_past_size(); i++)
+ if (node->get_read_from_past(i) == write)
+ return true;
+ return false;
+}
+
+/**
+ * @brief Checks the NodeStack to see if a Promise is in our may-read-from set
+ * @param promise The Promise to check for
+ * @return True if the Promise is found; false otherwise
+ */
+bool ModelAction::may_read_from(const Promise *promise) const
+{
+ for (int i = 0; i < node->get_read_from_promise_size(); i++)
+ if (node->get_read_from_promise(i) == promise)
+ return true;
+ return false;
+}
+
+/**
+ * Only valid for LOCK, TRY_LOCK, UNLOCK, and WAIT operations.
+ * @return The mutex operated on by this action, if any; otherwise NULL
+ */
+std::mutex * ModelAction::get_mutex() const
+{
+ if (is_trylock() || is_lock() || is_unlock())
+ return (std::mutex *)get_location();
+ else if (is_wait())
+ return (std::mutex *)get_value();
+ else
+ return NULL;
+}
--- /dev/null
+/** @file action.h
+ * @brief Models actions taken by threads.
+ */
+
+#ifndef __ACTION_H__
+#define __ACTION_H__
+
+#include <cstddef>
+#include <inttypes.h>
+
+#include "mymemory.h"
+#include "memoryorder.h"
+#include "modeltypes.h"
+
+/* Forward declarations */
+class ClockVector;
+class Thread;
+class Promise;
+
+namespace std {
+ class mutex;
+}
+
+using std::memory_order;
+using std::memory_order_relaxed;
+using std::memory_order_acquire;
+using std::memory_order_release;
+using std::memory_order_acq_rel;
+using std::memory_order_seq_cst;
+
+/**
+ * @brief A recognizable don't-care value for use in the ModelAction::value
+ * field
+ *
+ * Note that this value can be legitimately used by a program, and hence by
+ * iteself does not indicate no value.
+ */
+#define VALUE_NONE 0xdeadbeef
+
+/**
+ * @brief The "location" at which a fence occurs
+ *
+ * We need a non-zero memory location to associate with fences, since our hash
+ * tables don't handle NULL-pointer keys. HACK: Hopefully this doesn't collide
+ * with any legitimate memory locations.
+ */
+#define FENCE_LOCATION ((void *)0x7)
+
+/** @brief Represents an action type, identifying one of several types of
+ * ModelAction */
+typedef enum action_type {
+ MODEL_FIXUP_RELSEQ, /**< Special ModelAction: finalize a release
+ * sequence */
+ THREAD_CREATE, /**< A thread creation action */
+ THREAD_START, /**< First action in each thread */
+ THREAD_YIELD, /**< A thread yield action */
+ THREAD_JOIN, /**< A thread join action */
+ THREAD_FINISH, /**< A thread completion action */
+ ATOMIC_UNINIT, /**< Represents an uninitialized atomic */
+ ATOMIC_READ, /**< An atomic read action */
+ ATOMIC_WRITE, /**< An atomic write action */
+ ATOMIC_RMWR, /**< The read part of an atomic RMW action */
+ ATOMIC_RMW, /**< The write part of an atomic RMW action */
+ ATOMIC_RMWC, /**< Convert an atomic RMW action into a READ */
+ ATOMIC_INIT, /**< Initialization of an atomic object (e.g.,
+ * atomic_init()) */
+ ATOMIC_FENCE, /**< A fence action */
+ ATOMIC_LOCK, /**< A lock action */
+ ATOMIC_TRYLOCK, /**< A trylock action */
+ ATOMIC_UNLOCK, /**< An unlock action */
+ ATOMIC_NOTIFY_ONE, /**< A notify_one action */
+ ATOMIC_NOTIFY_ALL, /**< A notify all action */
+ ATOMIC_WAIT, /**< A wait action */
+ ATOMIC_ANNOTATION /**< An annotation action to pass information
+ to a trace analysis */
+} action_type_t;
+
+/* Forward declaration */
+class Node;
+class ClockVector;
+
+/**
+ * @brief Represents a single atomic action
+ *
+ * A ModelAction is always allocated as non-snapshotting, because it is used in
+ * multiple executions during backtracking. Except for fake uninitialized
+ * (ATOMIC_UNINIT) ModelActions, each action is assigned a unique sequence
+ * number.
+ */
+class ModelAction {
+public:
+ ModelAction(action_type_t type, memory_order order, void *loc, uint64_t value = VALUE_NONE, Thread *thread = NULL);
+ ~ModelAction();
+ void print() const;
+
+ thread_id_t get_tid() const { return tid; }
+ action_type get_type() const { return type; }
+ memory_order get_mo() const { return order; }
+ void * get_location() const { return location; }
+ modelclock_t get_seq_number() const { return seq_number; }
+ uint64_t get_value() const { return value; }
+ uint64_t get_reads_from_value() const;
+ uint64_t get_write_value() const;
+ uint64_t get_return_value() const;
+ const ModelAction * get_reads_from() const { return reads_from; }
+ Promise * get_reads_from_promise() const { return reads_from_promise; }
+ std::mutex * get_mutex() const;
+
+ Node * get_node() const;
+ void set_node(Node *n) { node = n; }
+
+ void set_read_from(const ModelAction *act);
+ void set_read_from_promise(Promise *promise);
+
+ /** Store the most recent fence-release from the same thread
+ * @param fence The fence-release that occured prior to this */
+ void set_last_fence_release(const ModelAction *fence) { last_fence_release = fence; }
+ /** @return The most recent fence-release from the same thread */
+ const ModelAction * get_last_fence_release() const { return last_fence_release; }
+
+ void copy_from_new(ModelAction *newaction);
+ void set_seq_number(modelclock_t num);
+ void set_try_lock(bool obtainedlock);
+ bool is_thread_start() const;
+ bool is_thread_join() const;
+ bool is_relseq_fixup() const;
+ bool is_mutex_op() const;
+ bool is_lock() const;
+ bool is_trylock() const;
+ bool is_unlock() const;
+ bool is_wait() const;
+ bool is_notify() const;
+ bool is_notify_one() const;
+ bool is_success_lock() const;
+ bool is_failed_trylock() const;
+ bool is_atomic_var() const;
+ bool is_uninitialized() const;
+ bool is_read() const;
+ bool is_write() const;
+ bool is_yield() const;
+ bool could_be_write() const;
+ bool is_rmwr() const;
+ bool is_rmwc() const;
+ bool is_rmw() const;
+ bool is_fence() const;
+ bool is_initialization() const;
+ bool is_annotation() const;
+ bool is_relaxed() const;
+ bool is_acquire() const;
+ bool is_release() const;
+ bool is_seqcst() const;
+ bool same_var(const ModelAction *act) const;
+ bool same_thread(const ModelAction *act) const;
+ bool is_conflicting_lock(const ModelAction *act) const;
+ bool could_synchronize_with(const ModelAction *act) const;
+
+ Thread * get_thread_operand() const;
+
+ void create_cv(const ModelAction *parent = NULL);
+ ClockVector * get_cv() const { return cv; }
+ bool synchronize_with(const ModelAction *act);
+
+ bool has_synchronized_with(const ModelAction *act) const;
+ bool happens_before(const ModelAction *act) const;
+
+ inline bool operator <(const ModelAction& act) const {
+ return get_seq_number() < act.get_seq_number();
+ }
+ inline bool operator >(const ModelAction& act) const {
+ return get_seq_number() > act.get_seq_number();
+ }
+
+ void process_rmw(ModelAction * act);
+ void copy_typeandorder(ModelAction * act);
+
+ void set_sleep_flag() { sleep_flag=true; }
+ bool get_sleep_flag() { return sleep_flag; }
+ unsigned int hash() const;
+
+ bool equals(const ModelAction *x) const { return this == x; }
+ bool equals(const Promise *x) const { return false; }
+
+ bool may_read_from(const ModelAction *write) const;
+ bool may_read_from(const Promise *promise) const;
+ MEMALLOC
+private:
+
+ const char * get_type_str() const;
+ const char * get_mo_str() const;
+
+ /** @brief Type of action (read, write, RMW, fence, thread create, etc.) */
+ action_type type;
+
+ /** @brief The memory order for this operation. */
+ memory_order order;
+
+ /** @brief A pointer to the memory location for this action. */
+ void *location;
+
+ /** @brief The thread id that performed this action. */
+ thread_id_t tid;
+
+ /** @brief The value written (for write or RMW; undefined for read) */
+ uint64_t value;
+
+ /**
+ * @brief The store that this action reads from
+ *
+ * Only valid for reads
+ */
+ const ModelAction *reads_from;
+
+ /**
+ * @brief The promise that this action reads from
+ *
+ * Only valid for reads
+ */
+ Promise *reads_from_promise;
+
+ /** @brief The last fence release from the same thread */
+ const ModelAction *last_fence_release;
+
+ /**
+ * @brief A back reference to a Node in NodeStack
+ *
+ * Only set if this ModelAction is saved on the NodeStack. (A
+ * ModelAction can be thrown away before it ever enters the NodeStack.)
+ */
+ Node *node;
+
+ /**
+ * @brief The sequence number of this action
+ *
+ * Except for ATOMIC_UNINIT actions, this number should be unique and
+ * should represent the action's position in the execution order.
+ */
+ modelclock_t seq_number;
+
+ /**
+ * @brief The clock vector for this operation
+ *
+ * Technically, this is only needed for potentially synchronizing
+ * (e.g., non-relaxed) operations, but it is very handy to have these
+ * vectors for all operations.
+ */
+ ClockVector *cv;
+
+ bool sleep_flag;
+};
+
+#endif /* __ACTION_H__ */
--- /dev/null
+#ifndef __BUGMESSAGE_H__
+#define __BUGMESSAGE_H__
+
+#include "common.h"
+#include "mymemory.h"
+
+struct bug_message {
+ bug_message(const char *str) {
+ const char *fmt = " [BUG] %s\n";
+ msg = (char *)snapshot_malloc(strlen(fmt) + strlen(str));
+ sprintf(msg, fmt, str);
+ }
+ ~bug_message() { if (msg) snapshot_free(msg); }
+
+ char *msg;
+ void print() { model_print("%s", msg); }
+
+ SNAPSHOTALLOC
+};
+
+#endif /* __BUGMESSAGE_H__ */
--- /dev/null
+#include <cstring>
+#include <stdlib.h>
+
+#include "action.h"
+#include "clockvector.h"
+#include "common.h"
+#include "threads-model.h"
+
+/**
+ * Constructs a new ClockVector, given a parent ClockVector and a first
+ * ModelAction. This constructor can assign appropriate default settings if no
+ * parent and/or action is supplied.
+ * @param parent is the previous ClockVector to inherit (i.e., clock from the
+ * same thread or the parent that created this thread)
+ * @param act is an action with which to update the ClockVector
+ */
+ClockVector::ClockVector(ClockVector *parent, ModelAction *act)
+{
+ ASSERT(act);
+ num_threads = int_to_id(act->get_tid()) + 1;
+ if (parent && parent->num_threads > num_threads)
+ num_threads = parent->num_threads;
+
+ clock = (modelclock_t *)snapshot_calloc(num_threads, sizeof(int));
+ if (parent)
+ std::memcpy(clock, parent->clock, parent->num_threads * sizeof(modelclock_t));
+
+ clock[id_to_int(act->get_tid())] = act->get_seq_number();
+}
+
+/** @brief Destructor */
+ClockVector::~ClockVector()
+{
+ snapshot_free(clock);
+}
+
+/**
+ * Merge a clock vector into this vector, using a pairwise comparison. The
+ * resulting vector length will be the maximum length of the two being merged.
+ * @param cv is the ClockVector being merged into this vector.
+ */
+bool ClockVector::merge(const ClockVector *cv)
+{
+ ASSERT(cv != NULL);
+ bool changed = false;
+ if (cv->num_threads > num_threads) {
+ clock = (modelclock_t *)snapshot_realloc(clock, cv->num_threads * sizeof(modelclock_t));
+ for (int i = num_threads; i < cv->num_threads; i++)
+ clock[i] = 0;
+ num_threads = cv->num_threads;
+ }
+
+ /* Element-wise maximum */
+ for (int i = 0; i < cv->num_threads; i++)
+ if (cv->clock[i] > clock[i]) {
+ clock[i] = cv->clock[i];
+ changed = true;
+ }
+
+ return changed;
+}
+
+/**
+ * Check whether this vector's thread has synchronized with another action's
+ * thread. This effectively checks the happens-before relation (or actually,
+ * happens after), but it's easier to compare two ModelAction events directly,
+ * using ModelAction::happens_before.
+ *
+ * @see ModelAction::happens_before
+ *
+ * @return true if this ClockVector's thread has synchronized with act's
+ * thread, false otherwise. That is, this function returns:
+ * <BR><CODE>act <= cv[act->tid]</CODE>
+ */
+bool ClockVector::synchronized_since(const ModelAction *act) const
+{
+ int i = id_to_int(act->get_tid());
+
+ if (i < num_threads)
+ return act->get_seq_number() <= clock[i];
+ return false;
+}
+
+/** Gets the clock corresponding to a given thread id from the clock vector. */
+modelclock_t ClockVector::getClock(thread_id_t thread) {
+ int threadid = id_to_int(thread);
+
+ if (threadid < num_threads)
+ return clock[threadid];
+ else
+ return 0;
+}
+
+/** @brief Formats and prints this ClockVector's data. */
+void ClockVector::print() const
+{
+ int i;
+ model_print("(");
+ for (i = 0; i < num_threads; i++)
+ model_print("%2u%s", clock[i], (i == num_threads - 1) ? ")\n" : ", ");
+}
--- /dev/null
+/** @file clockvector.h
+ * @brief Implements a clock vector.
+ */
+
+#ifndef __CLOCKVECTOR_H__
+#define __CLOCKVECTOR_H__
+
+#include "mymemory.h"
+#include "modeltypes.h"
+
+/* Forward declaration */
+class ModelAction;
+
+class ClockVector {
+public:
+ ClockVector(ClockVector *parent = NULL, ModelAction *act = NULL);
+ ~ClockVector();
+ bool merge(const ClockVector *cv);
+ bool synchronized_since(const ModelAction *act) const;
+
+ void print() const;
+ modelclock_t getClock(thread_id_t thread);
+
+ SNAPSHOTALLOC
+private:
+ /** @brief Holds the actual clock data, as an array. */
+ modelclock_t *clock;
+
+ /** @brief The number of threads recorded in clock (i.e., its length). */
+ int num_threads;
+};
+
+#endif /* __CLOCKVECTOR_H__ */
--- /dev/null
+#include "model.h"
+#include "action.h"
+#include "cmodelint.h"
+#include "threads-model.h"
+
+/** Performs a read action.*/
+uint64_t model_read_action(void * obj, memory_order ord) {
+ return model->switch_to_master(new ModelAction(ATOMIC_READ, ord, obj));
+}
+
+/** Performs a write action.*/
+void model_write_action(void * obj, memory_order ord, uint64_t val) {
+ model->switch_to_master(new ModelAction(ATOMIC_WRITE, ord, obj, val));
+}
+
+/** Performs an init action. */
+void model_init_action(void * obj, uint64_t val) {
+ model->switch_to_master(new ModelAction(ATOMIC_INIT, memory_order_relaxed, obj, val));
+}
+
+/**
+ * Performs the read part of a RMW action. The next action must either be the
+ * write part of the RMW action or an explicit close out of the RMW action w/o
+ * a write.
+ */
+uint64_t model_rmwr_action(void *obj, memory_order ord) {
+ return model->switch_to_master(new ModelAction(ATOMIC_RMWR, ord, obj));
+}
+
+/** Performs the write part of a RMW action. */
+void model_rmw_action(void *obj, memory_order ord, uint64_t val) {
+ model->switch_to_master(new ModelAction(ATOMIC_RMW, ord, obj, val));
+}
+
+/** Closes out a RMW action without doing a write. */
+void model_rmwc_action(void *obj, memory_order ord) {
+ model->switch_to_master(new ModelAction(ATOMIC_RMWC, ord, obj));
+}
+
+/** Issues a fence operation. */
+void model_fence_action(memory_order ord) {
+ model->switch_to_master(new ModelAction(ATOMIC_FENCE, ord, FENCE_LOCATION));
+}
--- /dev/null
+#include <execinfo.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#include <model-assert.h>
+
+#include "common.h"
+#include "model.h"
+#include "stacktrace.h"
+#include "output.h"
+
+#define MAX_TRACE_LEN 100
+
+/** @brief Model-checker output file descriptor; default to stdout until redirected */
+int model_out = STDOUT_FILENO;
+
+#define CONFIG_STACKTRACE
+/** Print a backtrace of the current program state. */
+void print_trace(void)
+{
+#ifdef CONFIG_STACKTRACE
+ print_stacktrace(model_out);
+#else
+ void *array[MAX_TRACE_LEN];
+ char **strings;
+ int size, i;
+
+ size = backtrace(array, MAX_TRACE_LEN);
+ strings = backtrace_symbols(array, size);
+
+ model_print("\nDumping stack trace (%d frames):\n", size);
+
+ for (i = 0; i < size; i++)
+ model_print("\t%s\n", strings[i]);
+
+ free(strings);
+#endif /* CONFIG_STACKTRACE */
+}
+
+void assert_hook(void)
+{
+ model_print("Add breakpoint to line %u in file %s.\n", __LINE__, __FILE__);
+}
+
+void model_assert(bool expr, const char *file, int line)
+{
+ if (!expr) {
+ char msg[100];
+ sprintf(msg, "Program has hit assertion in file %s at line %d\n",
+ file, line);
+ model->assert_user_bug(msg);
+ }
+}
+
+#ifndef CONFIG_DEBUG
+
+static int fd_user_out; /**< @brief File descriptor from which to read user program output */
+
+/**
+ * @brief Setup output redirecting
+ *
+ * Redirects user program's stdout to a pipe so that we can dump it
+ * selectively, when displaying bugs, etc.
+ * Also connects a file descriptor 'model_out' directly to stdout, for printing
+ * data when needed.
+ *
+ * The model-checker can selectively choose to print/hide the user program
+ * output.
+ * @see clear_program_output
+ * @see print_program_output
+ *
+ * Note that the user program's pipe has limited memory, so if a program will
+ * output much data, we will need to buffer it in user-space during execution.
+ * This also means that if ModelChecker decides not to print an execution, it
+ * should promptly clear the pipe.
+ *
+ * This function should only be called once.
+ */
+void redirect_output()
+{
+ /* Save stdout for later use */
+ model_out = dup(STDOUT_FILENO);
+ if (model_out < 0) {
+ perror("dup");
+ exit(EXIT_FAILURE);
+ }
+
+ /* Redirect program output to a pipe */
+ int pipefd[2];
+ if (pipe(pipefd) < 0) {
+ perror("pipe");
+ exit(EXIT_FAILURE);
+ }
+ if (dup2(pipefd[1], STDOUT_FILENO) < 0) {
+ perror("dup2");
+ exit(EXIT_FAILURE);
+ }
+ close(pipefd[1]);
+
+ /* Save the "read" side of the pipe for use later */
+ if (fcntl(pipefd[0], F_SETFL, O_NONBLOCK) < 0) {
+ perror("fcntl");
+ exit(EXIT_FAILURE);
+ }
+ fd_user_out = pipefd[0];
+}
+
+/**
+ * @brief Wrapper for reading data to buffer
+ *
+ * Besides a simple read, this handles the subtleties of EOF and nonblocking
+ * input (if fd is O_NONBLOCK).
+ *
+ * @param fd The file descriptor to read.
+ * @param buf Buffer to read to.
+ * @param maxlen Maximum data to read to buffer
+ * @return The length of data read. If zero, then we hit EOF or ran out of data
+ * (non-blocking)
+ */
+static ssize_t read_to_buf(int fd, char *buf, size_t maxlen)
+{
+ ssize_t ret = read(fd, buf, maxlen);
+ if (ret < 0) {
+ if (errno == EAGAIN || errno == EWOULDBLOCK) {
+ return 0;
+ } else {
+ perror("read");
+ exit(EXIT_FAILURE);
+ }
+ }
+ return ret;
+}
+
+/** @brief Dump any pending program output without printing */
+void clear_program_output()
+{
+ fflush(stdout);
+ char buf[200];
+ while (read_to_buf(fd_user_out, buf, sizeof(buf)));
+}
+
+/** @brief Print out any pending program output */
+void print_program_output()
+{
+ char buf[200];
+
+ model_print("---- BEGIN PROGRAM OUTPUT ----\n");
+
+ /* Gather all program output */
+ fflush(stdout);
+
+ /* Read program output pipe and write to (real) stdout */
+ ssize_t ret;
+ while (1) {
+ ret = read_to_buf(fd_user_out, buf, sizeof(buf));
+ if (!ret)
+ break;
+ while (ret > 0) {
+ ssize_t res = write(model_out, buf, ret);
+ if (res < 0) {
+ perror("write");
+ exit(EXIT_FAILURE);
+ }
+ ret -= res;
+ }
+ }
+
+ model_print("---- END PROGRAM OUTPUT ----\n");
+}
+#endif /* ! CONFIG_DEBUG */
--- /dev/null
+/** @file common.h
+ * @brief General purpose macros.
+ */
+
+#ifndef __COMMON_H__
+#define __COMMON_H__
+
+#include <stdio.h>
+#include "config.h"
+
+extern int model_out;
+
+#define model_print(fmt, ...) do { dprintf(model_out, fmt, ##__VA_ARGS__); } while (0)
+
+#ifdef CONFIG_DEBUG
+#define DEBUG(fmt, ...) do { model_print("*** %15s:%-4d %25s() *** " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); } while (0)
+#define DBG() DEBUG("\n")
+#define DBG_ENABLED() (1)
+#else
+#define DEBUG(fmt, ...)
+#define DBG()
+#define DBG_ENABLED() (0)
+#endif
+
+void assert_hook(void);
+
+#ifdef CONFIG_ASSERT
+#define ASSERT(expr) \
+do { \
+ if (!(expr)) { \
+ fprintf(stderr, "Error: assertion failed in %s at line %d\n", __FILE__, __LINE__); \
+ /* print_trace(); // Trace printing may cause dynamic memory allocation */ \
+ assert_hook(); \
+ exit(EXIT_FAILURE); \
+ } \
+} while (0)
+#else
+#define ASSERT(expr) \
+ do { } while (0)
+#endif /* CONFIG_ASSERT */
+
+#define error_msg(...) fprintf(stderr, "Error: " __VA_ARGS__)
+
+void print_trace(void);
+#endif /* __COMMON_H__ */
--- /dev/null
+# A few common Makefile items
+
+CC := gcc
+CXX := g++
+
+UNAME := $(shell uname)
+
+LIB_NAME := model
+LIB_SO := lib$(LIB_NAME).so
+
+CPPFLAGS += -Wall -g -O3
+
+# Mac OSX options
+ifeq ($(UNAME), Darwin)
+CPPFLAGS += -D_XOPEN_SOURCE -DMAC
+endif
--- /dev/null
+#include <mutex>
+#include "model.h"
+#include <condition_variable>
+#include "action.h"
+
+namespace std {
+
+condition_variable::condition_variable() {
+
+}
+
+condition_variable::~condition_variable() {
+
+}
+
+void condition_variable::notify_one() {
+ model->switch_to_master(new ModelAction(ATOMIC_NOTIFY_ONE, std::memory_order_seq_cst, this));
+}
+
+void condition_variable::notify_all() {
+ model->switch_to_master(new ModelAction(ATOMIC_NOTIFY_ALL, std::memory_order_seq_cst, this));
+}
+
+void condition_variable::wait(mutex& lock) {
+ model->switch_to_master(new ModelAction(ATOMIC_WAIT, std::memory_order_seq_cst, this, (uint64_t) &lock));
+ //relock as a second action
+ lock.lock();
+}
+}
+
--- /dev/null
+/** @file config.h
+ * @brief Configuration file.
+ */
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+/** Turn on debugging. */
+/* #ifndef CONFIG_DEBUG
+ #define CONFIG_DEBUG
+ #endif
+
+ #ifndef CONFIG_ASSERT
+ #define CONFIG_ASSERT
+ #endif
+*/
+
+/** Turn on support for dumping cyclegraphs as dot files at each
+ * printed summary.*/
+#define SUPPORT_MOD_ORDER_DUMP 0
+
+/** Do we have a 48 bit virtual address (64 bit machine) or 32 bit addresses.
+ * Set to 1 for 48-bit, 0 for 32-bit. */
+#ifndef BIT48
+#ifdef _LP64
+#define BIT48 1
+#else
+#define BIT48 0
+#endif
+#endif /* BIT48 */
+
+/** Snapshotting configurables */
+
+/**
+ * If USE_MPROTECT_SNAPSHOT=2, then snapshot by tuned mmap() algorithm
+ * If USE_MPROTECT_SNAPSHOT=1, then snapshot by using mmap() and mprotect()
+ * If USE_MPROTECT_SNAPSHOT=0, then snapshot by using fork() */
+#define USE_MPROTECT_SNAPSHOT 2
+
+/** Size of signal stack */
+#define SIGSTACKSIZE 65536
+
+/** Page size configuration */
+#define PAGESIZE 4096
+
+/** Thread parameters */
+
+/* Size of stack to allocate for a thread. */
+#define STACK_SIZE (1024 * 1024)
+
+/** How many shadow tables of memory to preallocate for data race detector. */
+#define SHADOWBASETABLES 4
+
+/** Enable debugging assertions (via ASSERT()) */
+#define CONFIG_ASSERT
+
+#endif
--- /dev/null
+#include "context.h"
+
+#ifdef MAC
+
+int model_swapcontext(ucontext_t *oucp, ucontext_t *ucp)
+{
+ /*
+ * Mac OSX swapcontext() clobbers some registers, so use a hand-rolled
+ * version with {get,set}context(). We can avoid the same problem
+ * (where optimizations can break the following code) because we don't
+ * statically link with the C library
+ */
+
+ /* volatile, so that 'i' doesn't get promoted to a register */
+ volatile int i = 0;
+
+ getcontext(oucp);
+
+ if (i == 0) {
+ i = 1;
+ setcontext(ucp);
+ }
+
+ return 0;
+}
+
+#endif /* MAC */
--- /dev/null
+/**
+ * @file context.h
+ * @brief ucontext header, since Mac OSX swapcontext() is broken
+ */
+
+#ifndef __CONTEXT_H__
+#define __CONTEXT_H__
+
+#include <ucontext.h>
+
+#ifdef MAC
+
+int model_swapcontext(ucontext_t *oucp, ucontext_t *ucp);
+
+#else /* !MAC */
+
+static inline int model_swapcontext(ucontext_t *oucp, ucontext_t *ucp)
+{
+ return swapcontext(oucp, ucp);
+}
+
+#endif /* !MAC */
+
+#endif /* __CONTEXT_H__ */
--- /dev/null
+#include "cyclegraph.h"
+#include "action.h"
+#include "common.h"
+#include "promise.h"
+#include "threads-model.h"
+
+/** Initializes a CycleGraph object. */
+CycleGraph::CycleGraph() :
+ discovered(new HashTable<const CycleNode *, const CycleNode *, uintptr_t, 4, model_malloc, model_calloc, model_free>(16)),
+ queue(new ModelVector<const CycleNode *>()),
+ hasCycles(false),
+ oldCycles(false)
+{
+}
+
+/** CycleGraph destructor */
+CycleGraph::~CycleGraph()
+{
+ delete queue;
+ delete discovered;
+}
+
+/**
+ * Add a CycleNode to the graph, corresponding to a store ModelAction
+ * @param act The write action that should be added
+ * @param node The CycleNode that corresponds to the store
+ */
+void CycleGraph::putNode(const ModelAction *act, CycleNode *node)
+{
+ actionToNode.put(act, node);
+#if SUPPORT_MOD_ORDER_DUMP
+ nodeList.push_back(node);
+#endif
+}
+
+/**
+ * Add a CycleNode to the graph, corresponding to a Promise
+ * @param promise The Promise that should be added
+ * @param node The CycleNode that corresponds to the Promise
+ */
+void CycleGraph::putNode(const Promise *promise, CycleNode *node)
+{
+ promiseToNode.put(promise, node);
+#if SUPPORT_MOD_ORDER_DUMP
+ nodeList.push_back(node);
+#endif
+}
+
+/**
+ * @brief Remove the Promise node from the graph
+ * @param promise The promise to remove from the graph
+ */
+void CycleGraph::erasePromiseNode(const Promise *promise)
+{
+ promiseToNode.put(promise, NULL);
+#if SUPPORT_MOD_ORDER_DUMP
+ /* Remove the promise node from nodeList */
+ CycleNode *node = getNode_noCreate(promise);
+ for (unsigned int i = 0; i < nodeList.size(); )
+ if (nodeList[i] == node)
+ nodeList.erase(nodeList.begin() + i);
+ else
+ i++;
+#endif
+}
+
+/** @return The corresponding CycleNode, if exists; otherwise NULL */
+CycleNode * CycleGraph::getNode_noCreate(const ModelAction *act) const
+{
+ return actionToNode.get(act);
+}
+
+/** @return The corresponding CycleNode, if exists; otherwise NULL */
+CycleNode * CycleGraph::getNode_noCreate(const Promise *promise) const
+{
+ return promiseToNode.get(promise);
+}
+
+/**
+ * @brief Returns the CycleNode corresponding to a given ModelAction
+ *
+ * Gets (or creates, if none exist) a CycleNode corresponding to a ModelAction
+ *
+ * @param action The ModelAction to find a node for
+ * @return The CycleNode paired with this action
+ */
+CycleNode * CycleGraph::getNode(const ModelAction *action)
+{
+ CycleNode *node = getNode_noCreate(action);
+ if (node == NULL) {
+ node = new CycleNode(action);
+ putNode(action, node);
+ }
+ return node;
+}
+
+/**
+ * @brief Returns a CycleNode corresponding to a promise
+ *
+ * Gets (or creates, if none exist) a CycleNode corresponding to a promised
+ * value.
+ *
+ * @param promise The Promise generated by a reader
+ * @return The CycleNode corresponding to the Promise
+ */
+CycleNode * CycleGraph::getNode(const Promise *promise)
+{
+ CycleNode *node = getNode_noCreate(promise);
+ if (node == NULL) {
+ node = new CycleNode(promise);
+ putNode(promise, node);
+ }
+ return node;
+}
+
+/**
+ * Resolve/satisfy a Promise with a particular store ModelAction, taking care
+ * of the CycleGraph cleanups, including merging any necessary CycleNodes.
+ *
+ * @param promise The Promise to resolve
+ * @param writer The store that will resolve this Promise
+ * @return false if the resolution results in a cycle (or fails in some other
+ * way); true otherwise
+ */
+bool CycleGraph::resolvePromise(const Promise *promise, ModelAction *writer)
+{
+ CycleNode *promise_node = promiseToNode.get(promise);
+ CycleNode *w_node = actionToNode.get(writer);
+ ASSERT(promise_node);
+
+ if (w_node)
+ return mergeNodes(w_node, promise_node);
+ /* No existing write-node; just convert the promise-node */
+ promise_node->resolvePromise(writer);
+ erasePromiseNode(promise_node->getPromise());
+ putNode(writer, promise_node);
+ return true;
+}
+
+/**
+ * @brief Merge two CycleNodes that represent the same write
+ *
+ * Note that this operation cannot be rolled back.
+ *
+ * @param w_node The write ModelAction node with which to merge
+ * @param p_node The Promise node to merge. Will be destroyed after this
+ * function.
+ *
+ * @return false if the merge cannot succeed; true otherwise
+ */
+bool CycleGraph::mergeNodes(CycleNode *w_node, CycleNode *p_node)
+{
+ ASSERT(!w_node->is_promise());
+ ASSERT(p_node->is_promise());
+
+ const Promise *promise = p_node->getPromise();
+ if (!promise->is_compatible(w_node->getAction()) ||
+ !promise->same_value(w_node->getAction()))
+ return false;
+
+ /* Transfer the RMW */
+ CycleNode *promise_rmw = p_node->getRMW();
+ if (promise_rmw && promise_rmw != w_node->getRMW() && w_node->setRMW(promise_rmw))
+ return false;
+
+ /* Transfer back edges to w_node */
+ while (p_node->getNumBackEdges() > 0) {
+ CycleNode *back = p_node->removeBackEdge();
+ if (back == w_node)
+ continue;
+ addNodeEdge(back, w_node);
+ if (hasCycles)
+ return false;
+ }
+
+ /* Transfer forward edges to w_node */
+ while (p_node->getNumEdges() > 0) {
+ CycleNode *forward = p_node->removeEdge();
+ if (forward == w_node)
+ continue;
+ addNodeEdge(w_node, forward);
+ if (hasCycles)
+ return false;
+ }
+
+ erasePromiseNode(promise);
+ /* Not deleting p_node, to maintain consistency if mergeNodes() fails */
+
+ return !hasCycles;
+}
+
+/**
+ * Adds an edge between two CycleNodes.
+ * @param fromnode The edge comes from this CycleNode
+ * @param tonode The edge points to this CycleNode
+ * @return True, if new edge(s) are added; otherwise false
+ */
+bool CycleGraph::addNodeEdge(CycleNode *fromnode, CycleNode *tonode)
+{
+ if (fromnode->addEdge(tonode)) {
+ rollbackvector.push_back(fromnode);
+ if (!hasCycles)
+ hasCycles = checkReachable(tonode, fromnode);
+ } else
+ return false; /* No new edge */
+
+ /*
+ * If the fromnode has a rmwnode that is not the tonode, we should
+ * follow its RMW chain to add an edge at the end, unless we encounter
+ * tonode along the way
+ */
+ CycleNode *rmwnode = fromnode->getRMW();
+ if (rmwnode) {
+ while (rmwnode != tonode && rmwnode->getRMW())
+ rmwnode = rmwnode->getRMW();
+
+ if (rmwnode != tonode) {
+ if (rmwnode->addEdge(tonode)) {
+ if (!hasCycles)
+ hasCycles = checkReachable(tonode, rmwnode);
+
+ rollbackvector.push_back(rmwnode);
+ }
+ }
+ }
+ return true;
+}
+
+/**
+ * @brief Add an edge between a write and the RMW which reads from it
+ *
+ * Handles special case of a RMW action, where the ModelAction rmw reads from
+ * the ModelAction/Promise from. The key differences are:
+ * -# No write can occur in between the @a rmw and @a from actions.
+ * -# Only one RMW action can read from a given write.
+ *
+ * @param from The edge comes from this ModelAction/Promise
+ * @param rmw The edge points to this ModelAction; this action must read from
+ * the ModelAction/Promise from
+ */
+template <typename T>
+void CycleGraph::addRMWEdge(const T *from, const ModelAction *rmw)
+{
+ ASSERT(from);
+ ASSERT(rmw);
+
+ CycleNode *fromnode = getNode(from);
+ CycleNode *rmwnode = getNode(rmw);
+
+ /* We assume that this RMW has no RMW reading from it yet */
+ ASSERT(!rmwnode->getRMW());
+
+ /* Two RMW actions cannot read from the same write. */
+ if (fromnode->setRMW(rmwnode))
+ hasCycles = true;
+ else
+ rmwrollbackvector.push_back(fromnode);
+
+ /* Transfer all outgoing edges from the from node to the rmw node */
+ /* This process should not add a cycle because either:
+ * (1) The rmw should not have any incoming edges yet if it is the
+ * new node or
+ * (2) the fromnode is the new node and therefore it should not
+ * have any outgoing edges.
+ */
+ for (unsigned int i = 0; i < fromnode->getNumEdges(); i++) {
+ CycleNode *tonode = fromnode->getEdge(i);
+ if (tonode != rmwnode) {
+ if (rmwnode->addEdge(tonode))
+ rollbackvector.push_back(rmwnode);
+ }
+ }
+
+ addNodeEdge(fromnode, rmwnode);
+}
+/* Instantiate two forms of CycleGraph::addRMWEdge */
+template void CycleGraph::addRMWEdge(const ModelAction *from, const ModelAction *rmw);
+template void CycleGraph::addRMWEdge(const Promise *from, const ModelAction *rmw);
+
+/**
+ * @brief Adds an edge between objects
+ *
+ * This function will add an edge between any two objects which can be
+ * associated with a CycleNode. That is, if they have a CycleGraph::getNode
+ * implementation.
+ *
+ * The object to is ordered after the object from.
+ *
+ * @param to The edge points to this object, of type T
+ * @param from The edge comes from this object, of type U
+ * @return True, if new edge(s) are added; otherwise false
+ */
+template <typename T, typename U>
+bool CycleGraph::addEdge(const T *from, const U *to)
+{
+ ASSERT(from);
+ ASSERT(to);
+
+ CycleNode *fromnode = getNode(from);
+ CycleNode *tonode = getNode(to);
+
+ return addNodeEdge(fromnode, tonode);
+}
+/* Instantiate four forms of CycleGraph::addEdge */
+template bool CycleGraph::addEdge(const ModelAction *from, const ModelAction *to);
+template bool CycleGraph::addEdge(const ModelAction *from, const Promise *to);
+template bool CycleGraph::addEdge(const Promise *from, const ModelAction *to);
+template bool CycleGraph::addEdge(const Promise *from, const Promise *to);
+
+#if SUPPORT_MOD_ORDER_DUMP
+
+static void print_node(FILE *file, const CycleNode *node, int label)
+{
+ if (node->is_promise()) {
+ const Promise *promise = node->getPromise();
+ int idx = promise->get_index();
+ fprintf(file, "P%u", idx);
+ if (label) {
+ int first = 1;
+ fprintf(file, " [label=\"P%d, T", idx);
+ for (unsigned int i = 0 ; i < promise->max_available_thread_idx(); i++)
+ if (promise->thread_is_available(int_to_id(i))) {
+ fprintf(file, "%s%u", first ? "": ",", i);
+ first = 0;
+ }
+ fprintf(file, "\"]");
+ }
+ } else {
+ const ModelAction *act = node->getAction();
+ modelclock_t idx = act->get_seq_number();
+ fprintf(file, "N%u", idx);
+ if (label)
+ fprintf(file, " [label=\"N%u, T%u\"]", idx, act->get_tid());
+ }
+}
+
+static void print_edge(FILE *file, const CycleNode *from, const CycleNode *to, const char *prop)
+{
+ print_node(file, from, 0);
+ fprintf(file, " -> ");
+ print_node(file, to, 0);
+ if (prop && strlen(prop))
+ fprintf(file, " [%s]", prop);
+ fprintf(file, ";\n");
+}
+
+void CycleGraph::dot_print_node(FILE *file, const ModelAction *act)
+{
+ print_node(file, getNode(act), 1);
+}
+
+template <typename T, typename U>
+void CycleGraph::dot_print_edge(FILE *file, const T *from, const U *to, const char *prop)
+{
+ CycleNode *fromnode = getNode(from);
+ CycleNode *tonode = getNode(to);
+
+ print_edge(file, fromnode, tonode, prop);
+}
+/* Instantiate two forms of CycleGraph::dot_print_edge */
+template void CycleGraph::dot_print_edge(FILE *file, const Promise *from, const ModelAction *to, const char *prop);
+template void CycleGraph::dot_print_edge(FILE *file, const ModelAction *from, const ModelAction *to, const char *prop);
+
+void CycleGraph::dumpNodes(FILE *file) const
+{
+ for (unsigned int i = 0; i < nodeList.size(); i++) {
+ CycleNode *n = nodeList[i];
+ print_node(file, n, 1);
+ fprintf(file, ";\n");
+ if (n->getRMW())
+ print_edge(file, n, n->getRMW(), "style=dotted");
+ for (unsigned int j = 0; j < n->getNumEdges(); j++)
+ print_edge(file, n, n->getEdge(j), NULL);
+ }
+}
+
+void CycleGraph::dumpGraphToFile(const char *filename) const
+{
+ char buffer[200];
+ sprintf(buffer, "%s.dot", filename);
+ FILE *file = fopen(buffer, "w");
+ fprintf(file, "digraph %s {\n", filename);
+ dumpNodes(file);
+ fprintf(file, "}\n");
+ fclose(file);
+}
+#endif
+
+/**
+ * Checks whether one CycleNode can reach another.
+ * @param from The CycleNode from which to begin exploration
+ * @param to The CycleNode to reach
+ * @return True, @a from can reach @a to; otherwise, false
+ */
+bool CycleGraph::checkReachable(const CycleNode *from, const CycleNode *to) const
+{
+ discovered->reset();
+ queue->clear();
+ queue->push_back(from);
+ discovered->put(from, from);
+ while (!queue->empty()) {
+ const CycleNode *node = queue->back();
+ queue->pop_back();
+ if (node == to)
+ return true;
+ for (unsigned int i = 0; i < node->getNumEdges(); i++) {
+ CycleNode *next = node->getEdge(i);
+ if (!discovered->contains(next)) {
+ discovered->put(next, next);
+ queue->push_back(next);
+ }
+ }
+ }
+ return false;
+}
+
+/**
+ * Checks whether one ModelAction/Promise can reach another ModelAction/Promise
+ * @param from The ModelAction or Promise from which to begin exploration
+ * @param to The ModelAction or Promise to reach
+ * @return True, @a from can reach @a to; otherwise, false
+ */
+template <typename T, typename U>
+bool CycleGraph::checkReachable(const T *from, const U *to) const
+{
+ CycleNode *fromnode = getNode_noCreate(from);
+ CycleNode *tonode = getNode_noCreate(to);
+
+ if (!fromnode || !tonode)
+ return false;
+
+ return checkReachable(fromnode, tonode);
+}
+/* Instantiate four forms of CycleGraph::checkReachable */
+template bool CycleGraph::checkReachable(const ModelAction *from,
+ const ModelAction *to) const;
+template bool CycleGraph::checkReachable(const ModelAction *from,
+ const Promise *to) const;
+template bool CycleGraph::checkReachable(const Promise *from,
+ const ModelAction *to) const;
+template bool CycleGraph::checkReachable(const Promise *from,
+ const Promise *to) const;
+
+/** @return True, if the promise has failed; false otherwise */
+bool CycleGraph::checkPromise(const ModelAction *fromact, Promise *promise) const
+{
+ discovered->reset();
+ queue->clear();
+ CycleNode *from = actionToNode.get(fromact);
+
+ queue->push_back(from);
+ discovered->put(from, from);
+ while (!queue->empty()) {
+ const CycleNode *node = queue->back();
+ queue->pop_back();
+
+ if (node->getPromise() == promise)
+ return true;
+ if (!node->is_promise() &&
+ promise->eliminate_thread(node->getAction()->get_tid()))
+ return true;
+
+ for (unsigned int i = 0; i < node->getNumEdges(); i++) {
+ CycleNode *next = node->getEdge(i);
+ if (!discovered->contains(next)) {
+ discovered->put(next, next);
+ queue->push_back(next);
+ }
+ }
+ }
+ return false;
+}
+
+/** @brief Begin a new sequence of graph additions which can be rolled back */
+void CycleGraph::startChanges()
+{
+ ASSERT(rollbackvector.empty());
+ ASSERT(rmwrollbackvector.empty());
+ ASSERT(oldCycles == hasCycles);
+}
+
+/** Commit changes to the cyclegraph. */
+void CycleGraph::commitChanges()
+{
+ rollbackvector.clear();
+ rmwrollbackvector.clear();
+ oldCycles = hasCycles;
+}
+
+/** Rollback changes to the previous commit. */
+void CycleGraph::rollbackChanges()
+{
+ for (unsigned int i = 0; i < rollbackvector.size(); i++)
+ rollbackvector[i]->removeEdge();
+
+ for (unsigned int i = 0; i < rmwrollbackvector.size(); i++)
+ rmwrollbackvector[i]->clearRMW();
+
+ hasCycles = oldCycles;
+ rollbackvector.clear();
+ rmwrollbackvector.clear();
+}
+
+/** @returns whether a CycleGraph contains cycles. */
+bool CycleGraph::checkForCycles() const
+{
+ return hasCycles;
+}
+
+/**
+ * @brief Constructor for a CycleNode
+ * @param act The ModelAction for this node
+ */
+CycleNode::CycleNode(const ModelAction *act) :
+ action(act),
+ promise(NULL),
+ hasRMW(NULL)
+{
+}
+
+/**
+ * @brief Constructor for a Promise CycleNode
+ * @param promise The Promise which was generated
+ */
+CycleNode::CycleNode(const Promise *promise) :
+ action(NULL),
+ promise(promise),
+ hasRMW(NULL)
+{
+}
+
+/**
+ * @param i The index of the edge to return
+ * @returns The CycleNode edge indexed by i
+ */
+CycleNode * CycleNode::getEdge(unsigned int i) const
+{
+ return edges[i];
+}
+
+/** @returns The number of edges leaving this CycleNode */
+unsigned int CycleNode::getNumEdges() const
+{
+ return edges.size();
+}
+
+/**
+ * @param i The index of the back edge to return
+ * @returns The CycleNode back-edge indexed by i
+ */
+CycleNode * CycleNode::getBackEdge(unsigned int i) const
+{
+ return back_edges[i];
+}
+
+/** @returns The number of edges entering this CycleNode */
+unsigned int CycleNode::getNumBackEdges() const
+{
+ return back_edges.size();
+}
+
+/**
+ * @brief Remove an element from a vector
+ * @param v The vector
+ * @param n The element to remove
+ * @return True if the element was found; false otherwise
+ */
+template <typename T>
+static bool vector_remove_node(SnapVector<T>& v, const T n)
+{
+ for (unsigned int i = 0; i < v.size(); i++) {
+ if (v[i] == n) {
+ v.erase(v.begin() + i);
+ return true;
+ }
+ }
+ return false;
+}
+
+/**
+ * @brief Remove a (forward) edge from this CycleNode
+ * @return The CycleNode which was popped, if one exists; otherwise NULL
+ */
+CycleNode * CycleNode::removeEdge()
+{
+ if (edges.empty())
+ return NULL;
+
+ CycleNode *ret = edges.back();
+ edges.pop_back();
+ vector_remove_node(ret->back_edges, this);
+ return ret;
+}
+
+/**
+ * @brief Remove a (back) edge from this CycleNode
+ * @return The CycleNode which was popped, if one exists; otherwise NULL
+ */
+CycleNode * CycleNode::removeBackEdge()
+{
+ if (back_edges.empty())
+ return NULL;
+
+ CycleNode *ret = back_edges.back();
+ back_edges.pop_back();
+ vector_remove_node(ret->edges, this);
+ return ret;
+}
+
+/**
+ * Adds an edge from this CycleNode to another CycleNode.
+ * @param node The node to which we add a directed edge
+ * @return True if this edge is a new edge; false otherwise
+ */
+bool CycleNode::addEdge(CycleNode *node)
+{
+ for (unsigned int i = 0; i < edges.size(); i++)
+ if (edges[i] == node)
+ return false;
+ edges.push_back(node);
+ node->back_edges.push_back(this);
+ return true;
+}
+
+/** @returns the RMW CycleNode that reads from the current CycleNode */
+CycleNode * CycleNode::getRMW() const
+{
+ return hasRMW;
+}
+
+/**
+ * Set a RMW action node that reads from the current CycleNode.
+ * @param node The RMW that reads from the current node
+ * @return True, if this node already was read by another RMW; false otherwise
+ * @see CycleGraph::addRMWEdge
+ */
+bool CycleNode::setRMW(CycleNode *node)
+{
+ if (hasRMW != NULL)
+ return true;
+ hasRMW = node;
+ return false;
+}
+
+/**
+ * Convert a Promise CycleNode into a concrete-valued CycleNode. Should only be
+ * used when there's no existing ModelAction CycleNode for this write.
+ *
+ * @param writer The ModelAction which wrote the future value represented by
+ * this CycleNode
+ */
+void CycleNode::resolvePromise(const ModelAction *writer)
+{
+ ASSERT(is_promise());
+ ASSERT(promise->is_compatible(writer));
+ action = writer;
+ promise = NULL;
+ ASSERT(!is_promise());
+}
--- /dev/null
+/**
+ * @file cyclegraph.h
+ * @brief Data structure to track ordering constraints on modification order
+ *
+ * Used to determine whether a total order exists that satisfies the ordering
+ * constraints.
+ */
+
+#ifndef __CYCLEGRAPH_H__
+#define __CYCLEGRAPH_H__
+
+#include <inttypes.h>
+#include <stdio.h>
+
+#include "hashtable.h"
+#include "config.h"
+#include "mymemory.h"
+#include "stl-model.h"
+
+class Promise;
+class CycleNode;
+class ModelAction;
+
+/** @brief A graph of Model Actions for tracking cycles. */
+class CycleGraph {
+ public:
+ CycleGraph();
+ ~CycleGraph();
+
+ template <typename T, typename U>
+ bool addEdge(const T *from, const U *to);
+
+ template <typename T>
+ void addRMWEdge(const T *from, const ModelAction *rmw);
+
+ bool checkForCycles() const;
+ bool checkPromise(const ModelAction *from, Promise *p) const;
+
+ template <typename T, typename U>
+ bool checkReachable(const T *from, const U *to) const;
+
+ void startChanges();
+ void commitChanges();
+ void rollbackChanges();
+#if SUPPORT_MOD_ORDER_DUMP
+ void dumpNodes(FILE *file) const;
+ void dumpGraphToFile(const char *filename) const;
+
+ void dot_print_node(FILE *file, const ModelAction *act);
+ template <typename T, typename U>
+ void dot_print_edge(FILE *file, const T *from, const U *to, const char *prop);
+#endif
+
+ bool resolvePromise(const Promise *promise, ModelAction *writer);
+
+ SNAPSHOTALLOC
+ private:
+ bool addNodeEdge(CycleNode *fromnode, CycleNode *tonode);
+ void putNode(const ModelAction *act, CycleNode *node);
+ void putNode(const Promise *promise, CycleNode *node);
+ void erasePromiseNode(const Promise *promise);
+ CycleNode * getNode(const ModelAction *act);
+ CycleNode * getNode(const Promise *promise);
+ CycleNode * getNode_noCreate(const ModelAction *act) const;
+ CycleNode * getNode_noCreate(const Promise *promise) const;
+ bool mergeNodes(CycleNode *node1, CycleNode *node2);
+
+ HashTable<const CycleNode *, const CycleNode *, uintptr_t, 4, model_malloc, model_calloc, model_free> *discovered;
+ ModelVector<const CycleNode *> * queue;
+
+
+ /** @brief A table for mapping ModelActions to CycleNodes */
+ HashTable<const ModelAction *, CycleNode *, uintptr_t, 4> actionToNode;
+ /** @brief A table for mapping Promises to CycleNodes */
+ HashTable<const Promise *, CycleNode *, uintptr_t, 4> promiseToNode;
+
+#if SUPPORT_MOD_ORDER_DUMP
+ SnapVector<CycleNode *> nodeList;
+#endif
+
+ bool checkReachable(const CycleNode *from, const CycleNode *to) const;
+
+ /** @brief A flag: true if this graph contains cycles */
+ bool hasCycles;
+ /** @brief The previous value of CycleGraph::hasCycles, for rollback */
+ bool oldCycles;
+
+ SnapVector<CycleNode *> rollbackvector;
+ SnapVector<CycleNode *> rmwrollbackvector;
+};
+
+/**
+ * @brief A node within a CycleGraph; corresponds either to one ModelAction or
+ * to a promised future value
+ */
+class CycleNode {
+ public:
+ CycleNode(const ModelAction *act);
+ CycleNode(const Promise *promise);
+ bool addEdge(CycleNode *node);
+ CycleNode * getEdge(unsigned int i) const;
+ unsigned int getNumEdges() const;
+ CycleNode * getBackEdge(unsigned int i) const;
+ unsigned int getNumBackEdges() const;
+ CycleNode * removeEdge();
+ CycleNode * removeBackEdge();
+
+ bool setRMW(CycleNode *);
+ CycleNode * getRMW() const;
+ void clearRMW() { hasRMW = NULL; }
+ const ModelAction * getAction() const { return action; }
+ const Promise * getPromise() const { return promise; }
+ bool is_promise() const { return !action; }
+ void resolvePromise(const ModelAction *writer);
+
+ SNAPSHOTALLOC
+ private:
+ /** @brief The ModelAction that this node represents */
+ const ModelAction *action;
+
+ /** @brief The promise represented by this node; only valid when action
+ * is NULL */
+ const Promise *promise;
+
+ /** @brief The edges leading out from this node */
+ SnapVector<CycleNode *> edges;
+
+ /** @brief The edges leading into this node */
+ SnapVector<CycleNode *> back_edges;
+
+ /** Pointer to a RMW node that reads from this node, or NULL, if none
+ * exists */
+ CycleNode *hasRMW;
+};
+
+#endif /* __CYCLEGRAPH_H__ */
--- /dev/null
+#include "datarace.h"
+#include "model.h"
+#include "threads-model.h"
+#include <stdio.h>
+#include <cstring>
+#include "mymemory.h"
+#include "clockvector.h"
+#include "config.h"
+#include "action.h"
+#include "execution.h"
+#include "stl-model.h"
+
+static struct ShadowTable *root;
+static SnapVector<DataRace *> *unrealizedraces;
+static void *memory_base;
+static void *memory_top;
+
+static const ModelExecution * get_execution()
+{
+ return model->get_execution();
+}
+
+/** This function initialized the data race detector. */
+void initRaceDetector()
+{
+ root = (struct ShadowTable *)snapshot_calloc(sizeof(struct ShadowTable), 1);
+ memory_base = snapshot_calloc(sizeof(struct ShadowBaseTable) * SHADOWBASETABLES, 1);
+ memory_top = ((char *)memory_base) + sizeof(struct ShadowBaseTable) * SHADOWBASETABLES;
+ unrealizedraces = new SnapVector<DataRace *>();
+}
+
+void * table_calloc(size_t size)
+{
+ if ((((char *)memory_base) + size) > memory_top) {
+ return snapshot_calloc(size, 1);
+ } else {
+ void *tmp = memory_base;
+ memory_base = ((char *)memory_base) + size;
+ return tmp;
+ }
+}
+
+/** This function looks up the entry in the shadow table corresponding to a
+ * given address.*/
+static uint64_t * lookupAddressEntry(const void *address)
+{
+ struct ShadowTable *currtable = root;
+#if BIT48
+ currtable = (struct ShadowTable *) currtable->array[(((uintptr_t)address) >> 32) & MASK16BIT];
+ if (currtable == NULL) {
+ currtable = (struct ShadowTable *)(root->array[(((uintptr_t)address) >> 32) & MASK16BIT] = table_calloc(sizeof(struct ShadowTable)));
+ }
+#endif
+
+ struct ShadowBaseTable *basetable = (struct ShadowBaseTable *)currtable->array[(((uintptr_t)address) >> 16) & MASK16BIT];
+ if (basetable == NULL) {
+ basetable = (struct ShadowBaseTable *)(currtable->array[(((uintptr_t)address) >> 16) & MASK16BIT] = table_calloc(sizeof(struct ShadowBaseTable)));
+ }
+ return &basetable->array[((uintptr_t)address) & MASK16BIT];
+}
+
+/**
+ * Compares a current clock-vector/thread-ID pair with a clock/thread-ID pair
+ * to check the potential for a data race.
+ * @param clock1 The current clock vector
+ * @param tid1 The current thread; paired with clock1
+ * @param clock2 The clock value for the potentially-racing action
+ * @param tid2 The thread ID for the potentially-racing action
+ * @return true if the current clock allows a race with the event at clock2/tid2
+ */
+static bool clock_may_race(ClockVector *clock1, thread_id_t tid1,
+ modelclock_t clock2, thread_id_t tid2)
+{
+ return tid1 != tid2 && clock2 != 0 && clock1->getClock(tid2) <= clock2;
+}
+
+/**
+ * Expands a record from the compact form to the full form. This is
+ * necessary for multiple readers or for very large thread ids or time
+ * stamps. */
+static void expandRecord(uint64_t *shadow)
+{
+ uint64_t shadowval = *shadow;
+
+ modelclock_t readClock = READVECTOR(shadowval);
+ thread_id_t readThread = int_to_id(RDTHREADID(shadowval));
+ modelclock_t writeClock = WRITEVECTOR(shadowval);
+ thread_id_t writeThread = int_to_id(WRTHREADID(shadowval));
+
+ struct RaceRecord *record = (struct RaceRecord *)snapshot_calloc(1, sizeof(struct RaceRecord));
+ record->writeThread = writeThread;
+ record->writeClock = writeClock;
+
+ if (readClock != 0) {
+ record->capacity = INITCAPACITY;
+ record->thread = (thread_id_t *)snapshot_malloc(sizeof(thread_id_t) * record->capacity);
+ record->readClock = (modelclock_t *)snapshot_malloc(sizeof(modelclock_t) * record->capacity);
+ record->numReads = 1;
+ record->thread[0] = readThread;
+ record->readClock[0] = readClock;
+ }
+ *shadow = (uint64_t) record;
+}
+
+/** This function is called when we detect a data race.*/
+static void reportDataRace(thread_id_t oldthread, modelclock_t oldclock, bool isoldwrite, ModelAction *newaction, bool isnewwrite, const void *address)
+{
+ struct DataRace *race = (struct DataRace *)snapshot_malloc(sizeof(struct DataRace));
+ race->oldthread = oldthread;
+ race->oldclock = oldclock;
+ race->isoldwrite = isoldwrite;
+ race->newaction = newaction;
+ race->isnewwrite = isnewwrite;
+ race->address = address;
+ unrealizedraces->push_back(race);
+
+ /* If the race is realized, bail out now. */
+ if (checkDataRaces())
+ model->switch_to_master(NULL);
+}
+
+/**
+ * @brief Check and report data races
+ *
+ * If the trace is feasible (a feasible prefix), clear out the list of
+ * unrealized data races, asserting any realized ones as execution bugs so that
+ * the model-checker will end the execution.
+ *
+ * @return True if any data races were realized
+ */
+bool checkDataRaces()
+{
+ if (get_execution()->isfeasibleprefix()) {
+ bool race_asserted = false;
+ /* Prune the non-racing unrealized dataraces */
+ for (unsigned i = 0; i < unrealizedraces->size(); i++) {
+ struct DataRace *race = (*unrealizedraces)[i];
+ if (clock_may_race(race->newaction->get_cv(), race->newaction->get_tid(), race->oldclock, race->oldthread)) {
+ assert_race(race);
+ race_asserted = true;
+ }
+ snapshot_free(race);
+ }
+ unrealizedraces->clear();
+ return race_asserted;
+ }
+ return false;
+}
+
+/**
+ * @brief Assert a data race
+ *
+ * Asserts a data race which is currently realized, causing the execution to
+ * end and stashing a message in the model-checker's bug list
+ *
+ * @param race The race to report
+ */
+void assert_race(struct DataRace *race)
+{
+ model->assert_bug(
+ "Data race detected @ address %p:\n"
+ " Access 1: %5s in thread %2d @ clock %3u\n"
+ " Access 2: %5s in thread %2d @ clock %3u",
+ race->address,
+ race->isoldwrite ? "write" : "read",
+ id_to_int(race->oldthread),
+ race->oldclock,
+ race->isnewwrite ? "write" : "read",
+ id_to_int(race->newaction->get_tid()),
+ race->newaction->get_seq_number()
+ );
+}
+
+/** This function does race detection for a write on an expanded record. */
+void fullRaceCheckWrite(thread_id_t thread, void *location, uint64_t *shadow, ClockVector *currClock)
+{
+ struct RaceRecord *record = (struct RaceRecord *)(*shadow);
+
+ /* Check for datarace against last read. */
+
+ for (int i = 0; i < record->numReads; i++) {
+ modelclock_t readClock = record->readClock[i];
+ thread_id_t readThread = record->thread[i];
+
+ /* Note that readClock can't actuall be zero here, so it could be
+ optimized. */
+
+ if (clock_may_race(currClock, thread, readClock, readThread)) {
+ /* We have a datarace */
+ reportDataRace(readThread, readClock, false, get_execution()->get_parent_action(thread), true, location);
+ }
+ }
+
+ /* Check for datarace against last write. */
+
+ modelclock_t writeClock = record->writeClock;
+ thread_id_t writeThread = record->writeThread;
+
+ if (clock_may_race(currClock, thread, writeClock, writeThread)) {
+ /* We have a datarace */
+ reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), true, location);
+ }
+
+ record->numReads = 0;
+ record->writeThread = thread;
+ modelclock_t ourClock = currClock->getClock(thread);
+ record->writeClock = ourClock;
+}
+
+/** This function does race detection on a write. */
+void raceCheckWrite(thread_id_t thread, void *location)
+{
+ uint64_t *shadow = lookupAddressEntry(location);
+ uint64_t shadowval = *shadow;
+ ClockVector *currClock = get_execution()->get_cv(thread);
+
+ /* Do full record */
+ if (shadowval != 0 && !ISSHORTRECORD(shadowval)) {
+ fullRaceCheckWrite(thread, location, shadow, currClock);
+ return;
+ }
+
+ int threadid = id_to_int(thread);
+ modelclock_t ourClock = currClock->getClock(thread);
+
+ /* Thread ID is too large or clock is too large. */
+ if (threadid > MAXTHREADID || ourClock > MAXWRITEVECTOR) {
+ expandRecord(shadow);
+ fullRaceCheckWrite(thread, location, shadow, currClock);
+ return;
+ }
+
+ /* Check for datarace against last read. */
+
+ modelclock_t readClock = READVECTOR(shadowval);
+ thread_id_t readThread = int_to_id(RDTHREADID(shadowval));
+
+ if (clock_may_race(currClock, thread, readClock, readThread)) {
+ /* We have a datarace */
+ reportDataRace(readThread, readClock, false, get_execution()->get_parent_action(thread), true, location);
+ }
+
+ /* Check for datarace against last write. */
+
+ modelclock_t writeClock = WRITEVECTOR(shadowval);
+ thread_id_t writeThread = int_to_id(WRTHREADID(shadowval));
+
+ if (clock_may_race(currClock, thread, writeClock, writeThread)) {
+ /* We have a datarace */
+ reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), true, location);
+ }
+ *shadow = ENCODEOP(0, 0, threadid, ourClock);
+}
+
+/** This function does race detection on a read for an expanded record. */
+void fullRaceCheckRead(thread_id_t thread, const void *location, uint64_t *shadow, ClockVector *currClock)
+{
+ struct RaceRecord *record = (struct RaceRecord *) (*shadow);
+
+ /* Check for datarace against last write. */
+
+ modelclock_t writeClock = record->writeClock;
+ thread_id_t writeThread = record->writeThread;
+
+ if (clock_may_race(currClock, thread, writeClock, writeThread)) {
+ /* We have a datarace */
+ reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), false, location);
+ }
+
+ /* Shorten vector when possible */
+
+ int copytoindex = 0;
+
+ for (int i = 0; i < record->numReads; i++) {
+ modelclock_t readClock = record->readClock[i];
+ thread_id_t readThread = record->thread[i];
+
+ /* Note that is not really a datarace check as reads cannott
+ actually race. It is just determining that this read subsumes
+ another in the sense that either this read races or neither
+ read races. Note that readClock can't actually be zero, so it
+ could be optimized. */
+
+ if (clock_may_race(currClock, thread, readClock, readThread)) {
+ /* Still need this read in vector */
+ if (copytoindex != i) {
+ record->readClock[copytoindex] = record->readClock[i];
+ record->thread[copytoindex] = record->thread[i];
+ }
+ copytoindex++;
+ }
+ }
+
+ if (copytoindex >= record->capacity) {
+ int newCapacity = record->capacity * 2;
+ thread_id_t *newthread = (thread_id_t *)snapshot_malloc(sizeof(thread_id_t) * newCapacity);
+ modelclock_t *newreadClock = (modelclock_t *)snapshot_malloc(sizeof(modelclock_t) * newCapacity);
+ std::memcpy(newthread, record->thread, record->capacity * sizeof(thread_id_t));
+ std::memcpy(newreadClock, record->readClock, record->capacity * sizeof(modelclock_t));
+ snapshot_free(record->readClock);
+ snapshot_free(record->thread);
+ record->readClock = newreadClock;
+ record->thread = newthread;
+ record->capacity = newCapacity;
+ }
+
+ modelclock_t ourClock = currClock->getClock(thread);
+
+ record->thread[copytoindex] = thread;
+ record->readClock[copytoindex] = ourClock;
+ record->numReads = copytoindex + 1;
+}
+
+/** This function does race detection on a read. */
+void raceCheckRead(thread_id_t thread, const void *location)
+{
+ uint64_t *shadow = lookupAddressEntry(location);
+ uint64_t shadowval = *shadow;
+ ClockVector *currClock = get_execution()->get_cv(thread);
+
+ /* Do full record */
+ if (shadowval != 0 && !ISSHORTRECORD(shadowval)) {
+ fullRaceCheckRead(thread, location, shadow, currClock);
+ return;
+ }
+
+ int threadid = id_to_int(thread);
+ modelclock_t ourClock = currClock->getClock(thread);
+
+ /* Thread ID is too large or clock is too large. */
+ if (threadid > MAXTHREADID || ourClock > MAXWRITEVECTOR) {
+ expandRecord(shadow);
+ fullRaceCheckRead(thread, location, shadow, currClock);
+ return;
+ }
+
+ /* Check for datarace against last write. */
+
+ modelclock_t writeClock = WRITEVECTOR(shadowval);
+ thread_id_t writeThread = int_to_id(WRTHREADID(shadowval));
+
+ if (clock_may_race(currClock, thread, writeClock, writeThread)) {
+ /* We have a datarace */
+ reportDataRace(writeThread, writeClock, true, get_execution()->get_parent_action(thread), false, location);
+ }
+
+ modelclock_t readClock = READVECTOR(shadowval);
+ thread_id_t readThread = int_to_id(RDTHREADID(shadowval));
+
+ if (clock_may_race(currClock, thread, readClock, readThread)) {
+ /* We don't subsume this read... Have to expand record. */
+ expandRecord(shadow);
+ fullRaceCheckRead(thread, location, shadow, currClock);
+ return;
+ }
+
+ *shadow = ENCODEOP(threadid, ourClock, id_to_int(writeThread), writeClock);
+}
+
+bool haveUnrealizedRaces()
+{
+ return !unrealizedraces->empty();
+}
--- /dev/null
+/** @file datarace.h
+ * @brief Data race detection code.
+ */
+
+#ifndef __DATARACE_H__
+#define __DATARACE_H__
+
+#include "config.h"
+#include <stdint.h>
+#include "modeltypes.h"
+
+/* Forward declaration */
+class ModelAction;
+
+struct ShadowTable {
+ void * array[65536];
+};
+
+struct ShadowBaseTable {
+ uint64_t array[65536];
+};
+
+struct DataRace {
+ /* Clock and thread associated with first action. This won't change in
+ response to synchronization. */
+
+ thread_id_t oldthread;
+ modelclock_t oldclock;
+ /* Record whether this is a write, so we can tell the user. */
+ bool isoldwrite;
+
+ /* Model action associated with second action. This could change as
+ a result of synchronization. */
+ ModelAction *newaction;
+ /* Record whether this is a write, so we can tell the user. */
+ bool isnewwrite;
+
+ /* Address of data race. */
+ const void *address;
+};
+
+#define MASK16BIT 0xffff
+
+void initRaceDetector();
+void raceCheckWrite(thread_id_t thread, void *location);
+void raceCheckRead(thread_id_t thread, const void *location);
+bool checkDataRaces();
+void assert_race(struct DataRace *race);
+bool haveUnrealizedRaces();
+
+/**
+ * @brief A record of information for detecting data races
+ */
+struct RaceRecord {
+ modelclock_t *readClock;
+ thread_id_t *thread;
+ int capacity;
+ int numReads;
+ thread_id_t writeThread;
+ modelclock_t writeClock;
+};
+
+#define INITCAPACITY 4
+
+#define ISSHORTRECORD(x) ((x)&0x1)
+
+#define THREADMASK 0xff
+#define RDTHREADID(x) (((x)>>1)&THREADMASK)
+#define READMASK 0x07fffff
+#define READVECTOR(x) (((x)>>9)&READMASK)
+
+#define WRTHREADID(x) (((x)>>32)&THREADMASK)
+
+#define WRITEMASK READMASK
+#define WRITEVECTOR(x) (((x)>>40)&WRITEMASK)
+
+/**
+ * The basic encoding idea is that (void *) either:
+ * -# points to a full record (RaceRecord) or
+ * -# encodes the information in a 64 bit word. Encoding is as
+ * follows:
+ * - lowest bit set to 1
+ * - next 8 bits are read thread id
+ * - next 23 bits are read clock vector
+ * - next 8 bits are write thread id
+ * - next 23 bits are write clock vector
+ */
+#define ENCODEOP(rdthread, rdtime, wrthread, wrtime) (0x1ULL | ((rdthread)<<1) | ((rdtime) << 9) | (((uint64_t)wrthread)<<32) | (((uint64_t)wrtime)<<40))
+
+#define MAXTHREADID (THREADMASK-1)
+#define MAXREADVECTOR (READMASK-1)
+#define MAXWRITEVECTOR (WRITEMASK-1)
+
+#endif /* __DATARACE_H__ */
--- /dev/null
+Copyright (c) 2004, John Gruber
+<http://daringfireball.net/>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+* Neither the name "Markdown" nor the names of its contributors may
+ be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as
+is" and any express or implied warranties, including, but not limited
+to, the implied warranties of merchantability and fitness for a
+particular purpose are disclaimed. In no event shall the copyright owner
+or contributors be liable for any direct, indirect, incidental, special,
+exemplary, or consequential damages (including, but not limited to,
+procurement of substitute goods or services; loss of use, data, or
+profits; or business interruption) however caused and on any theory of
+liability, whether in contract, strict liability, or tort (including
+negligence or otherwise) arising in any way out of the use of this
+software, even if advised of the possibility of such damage.
--- /dev/null
+Markdown
+========
+
+Version 1.0.1 - Tue 14 Dec 2004
+
+by John Gruber
+<http://daringfireball.net/>
+
+
+Introduction
+------------
+
+Markdown is a text-to-HTML conversion tool for web writers. Markdown
+allows you to write using an easy-to-read, easy-to-write plain text
+format, then convert it to structurally valid XHTML (or HTML).
+
+Thus, "Markdown" is two things: a plain text markup syntax, and a
+software tool, written in Perl, that converts the plain text markup
+to HTML.
+
+Markdown works both as a Movable Type plug-in and as a standalone Perl
+script -- which means it can also be used as a text filter in BBEdit
+(or any other application that supporst filters written in Perl).
+
+Full documentation of Markdown's syntax and configuration options is
+available on the web: <http://daringfireball.net/projects/markdown/>.
+(Note: this readme file is formatted in Markdown.)
+
+
+
+Installation and Requirements
+-----------------------------
+
+Markdown requires Perl 5.6.0 or later. Welcome to the 21st Century.
+Markdown also requires the standard Perl library module `Digest::MD5`.
+
+
+### Movable Type ###
+
+Markdown works with Movable Type version 2.6 or later (including
+MT 3.0 or later).
+
+1. Copy the "Markdown.pl" file into your Movable Type "plugins"
+ directory. The "plugins" directory should be in the same directory
+ as "mt.cgi"; if the "plugins" directory doesn't already exist, use
+ your FTP program to create it. Your installation should look like
+ this:
+
+ (mt home)/plugins/Markdown.pl
+
+2. Once installed, Markdown will appear as an option in Movable Type's
+ Text Formatting pop-up menu. This is selectable on a per-post basis.
+ Markdown translates your posts to HTML when you publish; the posts
+ themselves are stored in your MT database in Markdown format.
+
+3. If you also install SmartyPants 1.5 (or later), Markdown will offer
+ a second text formatting option: "Markdown with SmartyPants". This
+ option is the same as the regular "Markdown" formatter, except that
+ automatically uses SmartyPants to create typographically correct
+ curly quotes, em-dashes, and ellipses. See the SmartyPants web page
+ for more information: <http://daringfireball.net/projects/smartypants/>
+
+4. To make Markdown (or "Markdown with SmartyPants") your default
+ text formatting option for new posts, go to Weblog Config ->
+ Preferences.
+
+Note that by default, Markdown produces XHTML output. To configure
+Markdown to produce HTML 4 output, see "Configuration", below.
+
+
+### Blosxom ###
+
+Markdown works with Blosxom version 2.x.
+
+1. Rename the "Markdown.pl" plug-in to "Markdown" (case is
+ important). Movable Type requires plug-ins to have a ".pl"
+ extension; Blosxom forbids it.
+
+2. Copy the "Markdown" plug-in file to your Blosxom plug-ins folder.
+ If you're not sure where your Blosxom plug-ins folder is, see the
+ Blosxom documentation for information.
+
+3. That's it. The entries in your weblog will now automatically be
+ processed by Markdown.
+
+4. If you'd like to apply Markdown formatting only to certain posts,
+ rather than all of them, see Jason Clark's instructions for using
+ Markdown in conjunction with Blosxom's Meta plugin:
+
+ <http://jclark.org/weblog/WebDev/Blosxom/Markdown.html>
+
+
+### BBEdit ###
+
+Markdown works with BBEdit 6.1 or later on Mac OS X. (It also works
+with BBEdit 5.1 or later and MacPerl 5.6.1 on Mac OS 8.6 or later.)
+
+1. Copy the "Markdown.pl" file to appropriate filters folder in your
+ "BBEdit Support" folder. On Mac OS X, this should be:
+
+ BBEdit Support/Unix Support/Unix Filters/
+
+ See the BBEdit documentation for more details on the location of
+ these folders.
+
+ You can rename "Markdown.pl" to whatever you wish.
+
+2. That's it. To use Markdown, select some text in a BBEdit document,
+ then choose Markdown from the Filters sub-menu in the "#!" menu, or
+ the Filters floating palette
+
+
+
+Configuration
+-------------
+
+By default, Markdown produces XHTML output for tags with empty elements.
+E.g.:
+
+ <br />
+
+Markdown can be configured to produce HTML-style tags; e.g.:
+
+ <br>
+
+
+### Movable Type ###
+
+You need to use a special `MTMarkdownOptions` container tag in each
+Movable Type template where you want HTML 4-style output:
+
+ <MTMarkdownOptions output='html4'>
+ ... put your entry content here ...
+ </MTMarkdownOptions>
+
+The easiest way to use MTMarkdownOptions is probably to put the
+opening tag right after your `<body>` tag, and the closing tag right
+before `</body>`.
+
+To suppress Markdown processing in a particular template, i.e. to
+publish the raw Markdown-formatted text without translation into
+(X)HTML, set the `output` attribute to 'raw':
+
+ <MTMarkdownOptions output='raw'>
+ ... put your entry content here ...
+ </MTMarkdownOptions>
+
+
+### Command-Line ###
+
+Use the `--html4tags` command-line switch to produce HTML output from a
+Unix-style command line. E.g.:
+
+ % perl Markdown.pl --html4tags foo.text
+
+Type `perldoc Markdown.pl`, or read the POD documentation within the
+Markdown.pl source code for more information.
+
+
+
+Bugs
+----
+
+To file bug reports or feature requests please send email to:
+<markdown@daringfireball.net>.
+
+
+
+Version History
+---------------
+
+1.0.1 (14 Dec 2004):
+
++ Changed the syntax rules for code blocks and spans. Previously,
+ backslash escapes for special Markdown characters were processed
+ everywhere other than within inline HTML tags. Now, the contents
+ of code blocks and spans are no longer processed for backslash
+ escapes. This means that code blocks and spans are now treated
+ literally, with no special rules to worry about regarding
+ backslashes.
+
+ **NOTE**: This changes the syntax from all previous versions of
+ Markdown. Code blocks and spans involving backslash characters
+ will now generate different output than before.
+
++ Tweaked the rules for link definitions so that they must occur
+ within three spaces of the left margin. Thus if you indent a link
+ definition by four spaces or a tab, it will now be a code block.
+
+ [a]: /url/ "Indented 3 spaces, this is a link def"
+
+ [b]: /url/ "Indented 4 spaces, this is a code block"
+
+ **IMPORTANT**: This may affect existing Markdown content if it
+ contains link definitions indented by 4 or more spaces.
+
++ Added `>`, `+`, and `-` to the list of backslash-escapable
+ characters. These should have been done when these characters
+ were added as unordered list item markers.
+
++ Trailing spaces and tabs following HTML comments and `<hr/>` tags
+ are now ignored.
+
++ Inline links using `<` and `>` URL delimiters weren't working:
+
+ like [this](<http://example.com/>)
+
++ Added a bit of tolerance for trailing spaces and tabs after
+ Markdown hr's.
+
++ Fixed bug where auto-links were being processed within code spans:
+
+ like this: `<http://example.com/>`
+
++ Sort-of fixed a bug where lines in the middle of hard-wrapped
+ paragraphs, which lines look like the start of a list item,
+ would accidentally trigger the creation of a list. E.g. a
+ paragraph that looked like this:
+
+ I recommend upgrading to version
+ 8. Oops, now this line is treated
+ as a sub-list.
+
+ This is fixed for top-level lists, but it can still happen for
+ sub-lists. E.g., the following list item will not be parsed
+ properly:
+
+ + I recommend upgrading to version
+ 8. Oops, now this line is treated
+ as a sub-list.
+
+ Given Markdown's list-creation rules, I'm not sure this can
+ be fixed.
+
++ Standalone HTML comments are now handled; previously, they'd get
+ wrapped in a spurious `<p>` tag.
+
++ Fix for horizontal rules preceded by 2 or 3 spaces.
+
++ `<hr>` HTML tags in must occur within three spaces of left
+ margin. (With 4 spaces or a tab, they should be code blocks, but
+ weren't before this fix.)
+
++ Capitalized "With" in "Markdown With SmartyPants" for
+ consistency with the same string label in SmartyPants.pl.
+ (This fix is specific to the MT plug-in interface.)
+
++ Auto-linked email address can now optionally contain
+ a 'mailto:' protocol. I.e. these are equivalent:
+
+ <mailto:user@example.com>
+ <user@example.com>
+
++ Fixed annoying bug where nested lists would wind up with
+ spurious (and invalid) `<p>` tags.
+
++ You can now write empty links:
+
+ [like this]()
+
+ and they'll be turned into anchor tags with empty href attributes.
+ This should have worked before, but didn't.
+
++ `***this***` and `___this___` are now turned into
+
+ <strong><em>this</em></strong>
+
+ Instead of
+
+ <strong><em>this</strong></em>
+
+ which isn't valid. (Thanks to Michel Fortin for the fix.)
+
++ Added a new substitution in `_EncodeCode()`: s/\$/$/g; This
+ is only for the benefit of Blosxom users, because Blosxom
+ (sometimes?) interpolates Perl scalars in your article bodies.
+
++ Fixed problem for links defined with urls that include parens, e.g.:
+
+ [1]: http://sources.wikipedia.org/wiki/Middle_East_Policy_(Chomsky)
+
+ "Chomsky" was being erroneously treated as the URL's title.
+
++ At some point during 1.0's beta cycle, I changed every sub's
+ argument fetching from this idiom:
+
+ my $text = shift;
+
+ to:
+
+ my $text = shift || return '';
+
+ The idea was to keep Markdown from doing any work in a sub
+ if the input was empty. This introduced a bug, though:
+ if the input to any function was the single-character string
+ "0", it would also evaluate as false and return immediately.
+ How silly. Now fixed.
+
+
+
+Donations
+---------
+
+Donations to support Markdown's development are happily accepted. See:
+<http://daringfireball.net/projects/markdown/> for details.
+
+
+
+Copyright and License
+---------------------
+
+Copyright (c) 2003-2004 John Gruber
+<http://daringfireball.net/>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+* Neither the name "Markdown" nor the names of its contributors may
+ be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as
+is" and any express or implied warranties, including, but not limited
+to, the implied warranties of merchantability and fitness for a
+particular purpose are disclaimed. In no event shall the copyright owner
+or contributors be liable for any direct, indirect, incidental, special,
+exemplary, or consequential damages (including, but not limited to,
+procurement of substitute goods or services; loss of use, data, or
+profits; or business interruption) however caused and on any theory of
+liability, whether in contract, strict liability, or tort (including
+negligence or otherwise) arising in any way out of the use of this
+software, even if advised of the possibility of such damage.
--- /dev/null
+#!/usr/bin/perl
+
+#
+# Markdown -- A text-to-HTML conversion tool for web writers
+#
+# Copyright (c) 2004 John Gruber
+# <http://daringfireball.net/projects/markdown/>
+#
+
+
+package Markdown;
+require 5.006_000;
+use strict;
+use warnings;
+
+use Digest::MD5 qw(md5_hex);
+use vars qw($VERSION);
+$VERSION = '1.0.1';
+# Tue 14 Dec 2004
+
+## Disabled; causes problems under Perl 5.6.1:
+# use utf8;
+# binmode( STDOUT, ":utf8" ); # c.f.: http://acis.openlib.org/dev/perl-unicode-struggle.html
+
+
+#
+# Global default settings:
+#
+my $g_empty_element_suffix = " />"; # Change to ">" for HTML output
+my $g_tab_width = 4;
+
+
+#
+# Globals:
+#
+
+# Regex to match balanced [brackets]. See Friedl's
+# "Mastering Regular Expressions", 2nd Ed., pp. 328-331.
+my $g_nested_brackets;
+$g_nested_brackets = qr{
+ (?> # Atomic matching
+ [^\[\]]+ # Anything other than brackets
+ |
+ \[
+ (??{ $g_nested_brackets }) # Recursive set of nested brackets
+ \]
+ )*
+}x;
+
+
+# Table of hash values for escaped characters:
+my %g_escape_table;
+foreach my $char (split //, '\\`*_{}[]()>#+-.!') {
+ $g_escape_table{$char} = md5_hex($char);
+}
+
+
+# Global hashes, used by various utility routines
+my %g_urls;
+my %g_titles;
+my %g_html_blocks;
+
+# Used to track when we're inside an ordered or unordered list
+# (see _ProcessListItems() for details):
+my $g_list_level = 0;
+
+
+#### Blosxom plug-in interface ##########################################
+
+# Set $g_blosxom_use_meta to 1 to use Blosxom's meta plug-in to determine
+# which posts Markdown should process, using a "meta-markup: markdown"
+# header. If it's set to 0 (the default), Markdown will process all
+# entries.
+my $g_blosxom_use_meta = 0;
+
+sub start { 1; }
+sub story {
+ my($pkg, $path, $filename, $story_ref, $title_ref, $body_ref) = @_;
+
+ if ( (! $g_blosxom_use_meta) or
+ (defined($meta::markup) and ($meta::markup =~ /^\s*markdown\s*$/i))
+ ){
+ $$body_ref = Markdown($$body_ref);
+ }
+ 1;
+}
+
+
+#### Movable Type plug-in interface #####################################
+eval {require MT}; # Test to see if we're running in MT.
+unless ($@) {
+ require MT;
+ import MT;
+ require MT::Template::Context;
+ import MT::Template::Context;
+
+ eval {require MT::Plugin}; # Test to see if we're running >= MT 3.0.
+ unless ($@) {
+ require MT::Plugin;
+ import MT::Plugin;
+ my $plugin = new MT::Plugin({
+ name => "Markdown",
+ description => "A plain-text-to-HTML formatting plugin. (Version: $VERSION)",
+ doc_link => 'http://daringfireball.net/projects/markdown/'
+ });
+ MT->add_plugin( $plugin );
+ }
+
+ MT::Template::Context->add_container_tag(MarkdownOptions => sub {
+ my $ctx = shift;
+ my $args = shift;
+ my $builder = $ctx->stash('builder');
+ my $tokens = $ctx->stash('tokens');
+
+ if (defined ($args->{'output'}) ) {
+ $ctx->stash('markdown_output', lc $args->{'output'});
+ }
+
+ defined (my $str = $builder->build($ctx, $tokens) )
+ or return $ctx->error($builder->errstr);
+ $str; # return value
+ });
+
+ MT->add_text_filter('markdown' => {
+ label => 'Markdown',
+ docs => 'http://daringfireball.net/projects/markdown/',
+ on_format => sub {
+ my $text = shift;
+ my $ctx = shift;
+ my $raw = 0;
+ if (defined $ctx) {
+ my $output = $ctx->stash('markdown_output');
+ if (defined $output && $output =~ m/^html/i) {
+ $g_empty_element_suffix = ">";
+ $ctx->stash('markdown_output', '');
+ }
+ elsif (defined $output && $output eq 'raw') {
+ $raw = 1;
+ $ctx->stash('markdown_output', '');
+ }
+ else {
+ $raw = 0;
+ $g_empty_element_suffix = " />";
+ }
+ }
+ $text = $raw ? $text : Markdown($text);
+ $text;
+ },
+ });
+
+ # If SmartyPants is loaded, add a combo Markdown/SmartyPants text filter:
+ my $smartypants;
+
+ {
+ no warnings "once";
+ $smartypants = $MT::Template::Context::Global_filters{'smarty_pants'};
+ }
+
+ if ($smartypants) {
+ MT->add_text_filter('markdown_with_smartypants' => {
+ label => 'Markdown With SmartyPants',
+ docs => 'http://daringfireball.net/projects/markdown/',
+ on_format => sub {
+ my $text = shift;
+ my $ctx = shift;
+ if (defined $ctx) {
+ my $output = $ctx->stash('markdown_output');
+ if (defined $output && $output eq 'html') {
+ $g_empty_element_suffix = ">";
+ }
+ else {
+ $g_empty_element_suffix = " />";
+ }
+ }
+ $text = Markdown($text);
+ $text = $smartypants->($text, '1');
+ },
+ });
+ }
+}
+else {
+#### BBEdit/command-line text filter interface ##########################
+# Needs to be hidden from MT (and Blosxom when running in static mode).
+
+ # We're only using $blosxom::version once; tell Perl not to warn us:
+ no warnings 'once';
+ unless ( defined($blosxom::version) ) {
+ use warnings;
+
+ #### Check for command-line switches: #################
+ my %cli_opts;
+ use Getopt::Long;
+ Getopt::Long::Configure('pass_through');
+ GetOptions(\%cli_opts,
+ 'version',
+ 'shortversion',
+ 'html4tags',
+ );
+ if ($cli_opts{'version'}) { # Version info
+ print "\nThis is Markdown, version $VERSION.\n";
+ print "Copyright 2004 John Gruber\n";
+ print "http://daringfireball.net/projects/markdown/\n\n";
+ exit 0;
+ }
+ if ($cli_opts{'shortversion'}) { # Just the version number string.
+ print $VERSION;
+ exit 0;
+ }
+ if ($cli_opts{'html4tags'}) { # Use HTML tag style instead of XHTML
+ $g_empty_element_suffix = ">";
+ }
+
+
+ #### Process incoming text: ###########################
+ my $text;
+ {
+ local $/; # Slurp the whole file
+ $text = <>;
+ }
+ print Markdown($text);
+ }
+}
+
+
+
+sub Markdown {
+#
+# Main function. The order in which other subs are called here is
+# essential. Link and image substitutions need to happen before
+# _EscapeSpecialChars(), so that any *'s or _'s in the <a>
+# and <img> tags get encoded.
+#
+ my $text = shift;
+
+ # Clear the global hashes. If we don't clear these, you get conflicts
+ # from other articles when generating a page which contains more than
+ # one article (e.g. an index page that shows the N most recent
+ # articles):
+ %g_urls = ();
+ %g_titles = ();
+ %g_html_blocks = ();
+
+
+ # Standardize line endings:
+ $text =~ s{\r\n}{\n}g; # DOS to Unix
+ $text =~ s{\r}{\n}g; # Mac to Unix
+
+ # Make sure $text ends with a couple of newlines:
+ $text .= "\n\n";
+
+ # Convert all tabs to spaces.
+ $text = _Detab($text);
+
+ # Strip any lines consisting only of spaces and tabs.
+ # This makes subsequent regexen easier to write, because we can
+ # match consecutive blank lines with /\n+/ instead of something
+ # contorted like /[ \t]*\n+/ .
+ $text =~ s/^[ \t]+$//mg;
+
+ # Turn block-level HTML blocks into hash entries
+ $text = _HashHTMLBlocks($text);
+
+ # Strip link definitions, store in hashes.
+ $text = _StripLinkDefinitions($text);
+
+ $text = _RunBlockGamut($text);
+
+ $text = _UnescapeSpecialChars($text);
+
+ return $text . "\n";
+}
+
+
+sub _StripLinkDefinitions {
+#
+# Strips link definitions from text, stores the URLs and titles in
+# hash references.
+#
+ my $text = shift;
+ my $less_than_tab = $g_tab_width - 1;
+
+ # Link defs are in the form: ^[id]: url "optional title"
+ while ($text =~ s{
+ ^[ ]{0,$less_than_tab}\[(.+)\]: # id = $1
+ [ \t]*
+ \n? # maybe *one* newline
+ [ \t]*
+ <?(\S+?)>? # url = $2
+ [ \t]*
+ \n? # maybe one newline
+ [ \t]*
+ (?:
+ (?<=\s) # lookbehind for whitespace
+ ["(]
+ (.+?) # title = $3
+ [")]
+ [ \t]*
+ )? # title is optional
+ (?:\n+|\Z)
+ }
+ {}mx) {
+ $g_urls{lc $1} = _EncodeAmpsAndAngles( $2 ); # Link IDs are case-insensitive
+ if ($3) {
+ $g_titles{lc $1} = $3;
+ $g_titles{lc $1} =~ s/"/"/g;
+ }
+ }
+
+ return $text;
+}
+
+
+sub _HashHTMLBlocks {
+ my $text = shift;
+ my $less_than_tab = $g_tab_width - 1;
+
+ # Hashify HTML blocks:
+ # We only want to do this for block-level HTML tags, such as headers,
+ # lists, and tables. That's because we still want to wrap <p>s around
+ # "paragraphs" that are wrapped in non-block-level tags, such as anchors,
+ # phrase emphasis, and spans. The list of tags we're looking for is
+ # hard-coded:
+ my $block_tags_a = qr/p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del/;
+ my $block_tags_b = qr/p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math/;
+
+ # First, look for nested blocks, e.g.:
+ # <div>
+ # <div>
+ # tags for inner block must be indented.
+ # </div>
+ # </div>
+ #
+ # The outermost tags must start at the left margin for this to match, and
+ # the inner nested divs must be indented.
+ # We need to do this before the next, more liberal match, because the next
+ # match will start at the first `<div>` and stop at the first `</div>`.
+ $text =~ s{
+ ( # save in $1
+ ^ # start of line (with /m)
+ <($block_tags_a) # start tag = $2
+ \b # word break
+ (.*\n)*? # any number of lines, minimally matching
+ </\2> # the matching end tag
+ [ \t]* # trailing spaces/tabs
+ (?=\n+|\Z) # followed by a newline or end of document
+ )
+ }{
+ my $key = md5_hex($1);
+ $g_html_blocks{$key} = $1;
+ "\n\n" . $key . "\n\n";
+ }egmx;
+
+
+ #
+ # Now match more liberally, simply from `\n<tag>` to `</tag>\n`
+ #
+ $text =~ s{
+ ( # save in $1
+ ^ # start of line (with /m)
+ <($block_tags_b) # start tag = $2
+ \b # word break
+ (.*\n)*? # any number of lines, minimally matching
+ .*</\2> # the matching end tag
+ [ \t]* # trailing spaces/tabs
+ (?=\n+|\Z) # followed by a newline or end of document
+ )
+ }{
+ my $key = md5_hex($1);
+ $g_html_blocks{$key} = $1;
+ "\n\n" . $key . "\n\n";
+ }egmx;
+ # Special case just for <hr />. It was easier to make a special case than
+ # to make the other regex more complicated.
+ $text =~ s{
+ (?:
+ (?<=\n\n) # Starting after a blank line
+ | # or
+ \A\n? # the beginning of the doc
+ )
+ ( # save in $1
+ [ ]{0,$less_than_tab}
+ <(hr) # start tag = $2
+ \b # word break
+ ([^<>])*? #
+ /?> # the matching end tag
+ [ \t]*
+ (?=\n{2,}|\Z) # followed by a blank line or end of document
+ )
+ }{
+ my $key = md5_hex($1);
+ $g_html_blocks{$key} = $1;
+ "\n\n" . $key . "\n\n";
+ }egx;
+
+ # Special case for standalone HTML comments:
+ $text =~ s{
+ (?:
+ (?<=\n\n) # Starting after a blank line
+ | # or
+ \A\n? # the beginning of the doc
+ )
+ ( # save in $1
+ [ ]{0,$less_than_tab}
+ (?s:
+ <!
+ (--.*?--\s*)+
+ >
+ )
+ [ \t]*
+ (?=\n{2,}|\Z) # followed by a blank line or end of document
+ )
+ }{
+ my $key = md5_hex($1);
+ $g_html_blocks{$key} = $1;
+ "\n\n" . $key . "\n\n";
+ }egx;
+
+
+ return $text;
+}
+
+
+sub _RunBlockGamut {
+#
+# These are all the transformations that form block-level
+# tags like paragraphs, headers, and list items.
+#
+ my $text = shift;
+
+ $text = _DoHeaders($text);
+
+ # Do Horizontal Rules:
+ $text =~ s{^[ ]{0,2}([ ]?\*[ ]?){3,}[ \t]*$}{\n<hr$g_empty_element_suffix\n}gmx;
+ $text =~ s{^[ ]{0,2}([ ]? -[ ]?){3,}[ \t]*$}{\n<hr$g_empty_element_suffix\n}gmx;
+ $text =~ s{^[ ]{0,2}([ ]? _[ ]?){3,}[ \t]*$}{\n<hr$g_empty_element_suffix\n}gmx;
+
+ $text = _DoLists($text);
+
+ $text = _DoCodeBlocks($text);
+
+ $text = _DoBlockQuotes($text);
+
+ # We already ran _HashHTMLBlocks() before, in Markdown(), but that
+ # was to escape raw HTML in the original Markdown source. This time,
+ # we're escaping the markup we've just created, so that we don't wrap
+ # <p> tags around block-level tags.
+ $text = _HashHTMLBlocks($text);
+
+ $text = _FormParagraphs($text);
+
+ return $text;
+}
+
+
+sub _RunSpanGamut {
+#
+# These are all the transformations that occur *within* block-level
+# tags like paragraphs, headers, and list items.
+#
+ my $text = shift;
+
+ $text = _DoCodeSpans($text);
+
+ $text = _EscapeSpecialChars($text);
+
+ # Process anchor and image tags. Images must come first,
+ # because ![foo][f] looks like an anchor.
+ $text = _DoImages($text);
+ $text = _DoAnchors($text);
+
+ # Make links out of things like `<http://example.com/>`
+ # Must come after _DoAnchors(), because you can use < and >
+ # delimiters in inline links like [this](<url>).
+ $text = _DoAutoLinks($text);
+
+ $text = _EncodeAmpsAndAngles($text);
+
+ $text = _DoItalicsAndBold($text);
+
+ # Do hard breaks:
+ $text =~ s/ {2,}\n/ <br$g_empty_element_suffix\n/g;
+
+ return $text;
+}
+
+
+sub _EscapeSpecialChars {
+ my $text = shift;
+ my $tokens ||= _TokenizeHTML($text);
+
+ $text = ''; # rebuild $text from the tokens
+# my $in_pre = 0; # Keep track of when we're inside <pre> or <code> tags.
+# my $tags_to_skip = qr!<(/?)(?:pre|code|kbd|script|math)[\s>]!;
+
+ foreach my $cur_token (@$tokens) {
+ if ($cur_token->[0] eq "tag") {
+ # Within tags, encode * and _ so they don't conflict
+ # with their use in Markdown for italics and strong.
+ # We're replacing each such character with its
+ # corresponding MD5 checksum value; this is likely
+ # overkill, but it should prevent us from colliding
+ # with the escape values by accident.
+ $cur_token->[1] =~ s! \* !$g_escape_table{'*'}!gx;
+ $cur_token->[1] =~ s! _ !$g_escape_table{'_'}!gx;
+ $text .= $cur_token->[1];
+ } else {
+ my $t = $cur_token->[1];
+ $t = _EncodeBackslashEscapes($t);
+ $text .= $t;
+ }
+ }
+ return $text;
+}
+
+
+sub _DoAnchors {
+#
+# Turn Markdown link shortcuts into XHTML <a> tags.
+#
+ my $text = shift;
+
+ #
+ # First, handle reference-style links: [link text] [id]
+ #
+ $text =~ s{
+ ( # wrap whole match in $1
+ \[
+ ($g_nested_brackets) # link text = $2
+ \]
+
+ [ ]? # one optional space
+ (?:\n[ ]*)? # one optional newline followed by spaces
+
+ \[
+ (.*?) # id = $3
+ \]
+ )
+ }{
+ my $result;
+ my $whole_match = $1;
+ my $link_text = $2;
+ my $link_id = lc $3;
+
+ if ($link_id eq "") {
+ $link_id = lc $link_text; # for shortcut links like [this][].
+ }
+
+ if (defined $g_urls{$link_id}) {
+ my $url = $g_urls{$link_id};
+ $url =~ s! \* !$g_escape_table{'*'}!gx; # We've got to encode these to avoid
+ $url =~ s! _ !$g_escape_table{'_'}!gx; # conflicting with italics/bold.
+ $result = "<a href=\"$url\"";
+ if ( defined $g_titles{$link_id} ) {
+ my $title = $g_titles{$link_id};
+ $title =~ s! \* !$g_escape_table{'*'}!gx;
+ $title =~ s! _ !$g_escape_table{'_'}!gx;
+ $result .= " title=\"$title\"";
+ }
+ $result .= ">$link_text</a>";
+ }
+ else {
+ $result = $whole_match;
+ }
+ $result;
+ }xsge;
+
+ #
+ # Next, inline-style links: [link text](url "optional title")
+ #
+ $text =~ s{
+ ( # wrap whole match in $1
+ \[
+ ($g_nested_brackets) # link text = $2
+ \]
+ \( # literal paren
+ [ \t]*
+ <?(.*?)>? # href = $3
+ [ \t]*
+ ( # $4
+ (['"]) # quote char = $5
+ (.*?) # Title = $6
+ \5 # matching quote
+ )? # title is optional
+ \)
+ )
+ }{
+ my $result;
+ my $whole_match = $1;
+ my $link_text = $2;
+ my $url = $3;
+ my $title = $6;
+
+ $url =~ s! \* !$g_escape_table{'*'}!gx; # We've got to encode these to avoid
+ $url =~ s! _ !$g_escape_table{'_'}!gx; # conflicting with italics/bold.
+ $result = "<a href=\"$url\"";
+
+ if (defined $title) {
+ $title =~ s/"/"/g;
+ $title =~ s! \* !$g_escape_table{'*'}!gx;
+ $title =~ s! _ !$g_escape_table{'_'}!gx;
+ $result .= " title=\"$title\"";
+ }
+
+ $result .= ">$link_text</a>";
+
+ $result;
+ }xsge;
+
+ return $text;
+}
+
+
+sub _DoImages {
+#
+# Turn Markdown image shortcuts into <img> tags.
+#
+ my $text = shift;
+
+ #
+ # First, handle reference-style labeled images: ![alt text][id]
+ #
+ $text =~ s{
+ ( # wrap whole match in $1
+ !\[
+ (.*?) # alt text = $2
+ \]
+
+ [ ]? # one optional space
+ (?:\n[ ]*)? # one optional newline followed by spaces
+
+ \[
+ (.*?) # id = $3
+ \]
+
+ )
+ }{
+ my $result;
+ my $whole_match = $1;
+ my $alt_text = $2;
+ my $link_id = lc $3;
+
+ if ($link_id eq "") {
+ $link_id = lc $alt_text; # for shortcut links like ![this][].
+ }
+
+ $alt_text =~ s/"/"/g;
+ if (defined $g_urls{$link_id}) {
+ my $url = $g_urls{$link_id};
+ $url =~ s! \* !$g_escape_table{'*'}!gx; # We've got to encode these to avoid
+ $url =~ s! _ !$g_escape_table{'_'}!gx; # conflicting with italics/bold.
+ $result = "<img src=\"$url\" alt=\"$alt_text\"";
+ if (defined $g_titles{$link_id}) {
+ my $title = $g_titles{$link_id};
+ $title =~ s! \* !$g_escape_table{'*'}!gx;
+ $title =~ s! _ !$g_escape_table{'_'}!gx;
+ $result .= " title=\"$title\"";
+ }
+ $result .= $g_empty_element_suffix;
+ }
+ else {
+ # If there's no such link ID, leave intact:
+ $result = $whole_match;
+ }
+
+ $result;
+ }xsge;
+
+ #
+ # Next, handle inline images: 
+ # Don't forget: encode * and _
+
+ $text =~ s{
+ ( # wrap whole match in $1
+ !\[
+ (.*?) # alt text = $2
+ \]
+ \( # literal paren
+ [ \t]*
+ <?(\S+?)>? # src url = $3
+ [ \t]*
+ ( # $4
+ (['"]) # quote char = $5
+ (.*?) # title = $6
+ \5 # matching quote
+ [ \t]*
+ )? # title is optional
+ \)
+ )
+ }{
+ my $result;
+ my $whole_match = $1;
+ my $alt_text = $2;
+ my $url = $3;
+ my $title = '';
+ if (defined($6)) {
+ $title = $6;
+ }
+
+ $alt_text =~ s/"/"/g;
+ $title =~ s/"/"/g;
+ $url =~ s! \* !$g_escape_table{'*'}!gx; # We've got to encode these to avoid
+ $url =~ s! _ !$g_escape_table{'_'}!gx; # conflicting with italics/bold.
+ $result = "<img src=\"$url\" alt=\"$alt_text\"";
+ if (defined $title) {
+ $title =~ s! \* !$g_escape_table{'*'}!gx;
+ $title =~ s! _ !$g_escape_table{'_'}!gx;
+ $result .= " title=\"$title\"";
+ }
+ $result .= $g_empty_element_suffix;
+
+ $result;
+ }xsge;
+
+ return $text;
+}
+
+
+sub _DoHeaders {
+ my $text = shift;
+
+ # Setext-style headers:
+ # Header 1
+ # ========
+ #
+ # Header 2
+ # --------
+ #
+ $text =~ s{ ^(.+)[ \t]*\n=+[ \t]*\n+ }{
+ "<h1>" . _RunSpanGamut($1) . "</h1>\n\n";
+ }egmx;
+
+ $text =~ s{ ^(.+)[ \t]*\n-+[ \t]*\n+ }{
+ "<h2>" . _RunSpanGamut($1) . "</h2>\n\n";
+ }egmx;
+
+
+ # atx-style headers:
+ # # Header 1
+ # ## Header 2
+ # ## Header 2 with closing hashes ##
+ # ...
+ # ###### Header 6
+ #
+ $text =~ s{
+ ^(\#{1,6}) # $1 = string of #'s
+ [ \t]*
+ (.+?) # $2 = Header text
+ [ \t]*
+ \#* # optional closing #'s (not counted)
+ \n+
+ }{
+ my $h_level = length($1);
+ "<h$h_level>" . _RunSpanGamut($2) . "</h$h_level>\n\n";
+ }egmx;
+
+ return $text;
+}
+
+
+sub _DoLists {
+#
+# Form HTML ordered (numbered) and unordered (bulleted) lists.
+#
+ my $text = shift;
+ my $less_than_tab = $g_tab_width - 1;
+
+ # Re-usable patterns to match list item bullets and number markers:
+ my $marker_ul = qr/[*+-]/;
+ my $marker_ol = qr/\d+[.]/;
+ my $marker_any = qr/(?:$marker_ul|$marker_ol)/;
+
+ # Re-usable pattern to match any entirel ul or ol list:
+ my $whole_list = qr{
+ ( # $1 = whole list
+ ( # $2
+ [ ]{0,$less_than_tab}
+ (${marker_any}) # $3 = first list item marker
+ [ \t]+
+ )
+ (?s:.+?)
+ ( # $4
+ \z
+ |
+ \n{2,}
+ (?=\S)
+ (?! # Negative lookahead for another list item marker
+ [ \t]*
+ ${marker_any}[ \t]+
+ )
+ )
+ )
+ }mx;
+
+ # We use a different prefix before nested lists than top-level lists.
+ # See extended comment in _ProcessListItems().
+ #
+ # Note: There's a bit of duplication here. My original implementation
+ # created a scalar regex pattern as the conditional result of the test on
+ # $g_list_level, and then only ran the $text =~ s{...}{...}egmx
+ # substitution once, using the scalar as the pattern. This worked,
+ # everywhere except when running under MT on my hosting account at Pair
+ # Networks. There, this caused all rebuilds to be killed by the reaper (or
+ # perhaps they crashed, but that seems incredibly unlikely given that the
+ # same script on the same server ran fine *except* under MT. I've spent
+ # more time trying to figure out why this is happening than I'd like to
+ # admit. My only guess, backed up by the fact that this workaround works,
+ # is that Perl optimizes the substition when it can figure out that the
+ # pattern will never change, and when this optimization isn't on, we run
+ # afoul of the reaper. Thus, the slightly redundant code to that uses two
+ # static s/// patterns rather than one conditional pattern.
+
+ if ($g_list_level) {
+ $text =~ s{
+ ^
+ $whole_list
+ }{
+ my $list = $1;
+ my $list_type = ($3 =~ m/$marker_ul/) ? "ul" : "ol";
+ # Turn double returns into triple returns, so that we can make a
+ # paragraph for the last item in a list, if necessary:
+ $list =~ s/\n{2,}/\n\n\n/g;
+ my $result = _ProcessListItems($list, $marker_any);
+ $result = "<$list_type>\n" . $result . "</$list_type>\n";
+ $result;
+ }egmx;
+ }
+ else {
+ $text =~ s{
+ (?:(?<=\n\n)|\A\n?)
+ $whole_list
+ }{
+ my $list = $1;
+ my $list_type = ($3 =~ m/$marker_ul/) ? "ul" : "ol";
+ # Turn double returns into triple returns, so that we can make a
+ # paragraph for the last item in a list, if necessary:
+ $list =~ s/\n{2,}/\n\n\n/g;
+ my $result = _ProcessListItems($list, $marker_any);
+ $result = "<$list_type>\n" . $result . "</$list_type>\n";
+ $result;
+ }egmx;
+ }
+
+
+ return $text;
+}
+
+
+sub _ProcessListItems {
+#
+# Process the contents of a single ordered or unordered list, splitting it
+# into individual list items.
+#
+
+ my $list_str = shift;
+ my $marker_any = shift;
+
+
+ # The $g_list_level global keeps track of when we're inside a list.
+ # Each time we enter a list, we increment it; when we leave a list,
+ # we decrement. If it's zero, we're not in a list anymore.
+ #
+ # We do this because when we're not inside a list, we want to treat
+ # something like this:
+ #
+ # I recommend upgrading to version
+ # 8. Oops, now this line is treated
+ # as a sub-list.
+ #
+ # As a single paragraph, despite the fact that the second line starts
+ # with a digit-period-space sequence.
+ #
+ # Whereas when we're inside a list (or sub-list), that line will be
+ # treated as the start of a sub-list. What a kludge, huh? This is
+ # an aspect of Markdown's syntax that's hard to parse perfectly
+ # without resorting to mind-reading. Perhaps the solution is to
+ # change the syntax rules such that sub-lists must start with a
+ # starting cardinal number; e.g. "1." or "a.".
+
+ $g_list_level++;
+
+ # trim trailing blank lines:
+ $list_str =~ s/\n{2,}\z/\n/;
+
+
+ $list_str =~ s{
+ (\n)? # leading line = $1
+ (^[ \t]*) # leading whitespace = $2
+ ($marker_any) [ \t]+ # list marker = $3
+ ((?s:.+?) # list item text = $4
+ (\n{1,2}))
+ (?= \n* (\z | \2 ($marker_any) [ \t]+))
+ }{
+ my $item = $4;
+ my $leading_line = $1;
+ my $leading_space = $2;
+
+ if ($leading_line or ($item =~ m/\n{2,}/)) {
+ $item = _RunBlockGamut(_Outdent($item));
+ }
+ else {
+ # Recursion for sub-lists:
+ $item = _DoLists(_Outdent($item));
+ chomp $item;
+ $item = _RunSpanGamut($item);
+ }
+
+ "<li>" . $item . "</li>\n";
+ }egmx;
+
+ $g_list_level--;
+ return $list_str;
+}
+
+
+
+sub _DoCodeBlocks {
+#
+# Process Markdown `<pre><code>` blocks.
+#
+
+ my $text = shift;
+
+ $text =~ s{
+ (?:\n\n|\A)
+ ( # $1 = the code block -- one or more lines, starting with a space/tab
+ (?:
+ (?:[ ]{$g_tab_width} | \t) # Lines must start with a tab or a tab-width of spaces
+ .*\n+
+ )+
+ )
+ ((?=^[ ]{0,$g_tab_width}\S)|\Z) # Lookahead for non-space at line-start, or end of doc
+ }{
+ my $codeblock = $1;
+ my $result; # return value
+
+ $codeblock = _EncodeCode(_Outdent($codeblock));
+ $codeblock = _Detab($codeblock);
+ $codeblock =~ s/\A\n+//; # trim leading newlines
+ $codeblock =~ s/\s+\z//; # trim trailing whitespace
+
+ $result = "\n\n<pre><code>" . $codeblock . "\n</code></pre>\n\n";
+
+ $result;
+ }egmx;
+
+ return $text;
+}
+
+
+sub _DoCodeSpans {
+#
+# * Backtick quotes are used for <code></code> spans.
+#
+# * You can use multiple backticks as the delimiters if you want to
+# include literal backticks in the code span. So, this input:
+#
+# Just type ``foo `bar` baz`` at the prompt.
+#
+# Will translate to:
+#
+# <p>Just type <code>foo `bar` baz</code> at the prompt.</p>
+#
+# There's no arbitrary limit to the number of backticks you
+# can use as delimters. If you need three consecutive backticks
+# in your code, use four for delimiters, etc.
+#
+# * You can use spaces to get literal backticks at the edges:
+#
+# ... type `` `bar` `` ...
+#
+# Turns to:
+#
+# ... type <code>`bar`</code> ...
+#
+
+ my $text = shift;
+
+ $text =~ s@
+ (`+) # $1 = Opening run of `
+ (.+?) # $2 = The code block
+ (?<!`)
+ \1 # Matching closer
+ (?!`)
+ @
+ my $c = "$2";
+ $c =~ s/^[ \t]*//g; # leading whitespace
+ $c =~ s/[ \t]*$//g; # trailing whitespace
+ $c = _EncodeCode($c);
+ "<code>$c</code>";
+ @egsx;
+
+ return $text;
+}
+
+
+sub _EncodeCode {
+#
+# Encode/escape certain characters inside Markdown code runs.
+# The point is that in code, these characters are literals,
+# and lose their special Markdown meanings.
+#
+ local $_ = shift;
+
+ # Encode all ampersands; HTML entities are not
+ # entities within a Markdown code span.
+ s/&/&/g;
+
+ # Encode $'s, but only if we're running under Blosxom.
+ # (Blosxom interpolates Perl variables in article bodies.)
+ {
+ no warnings 'once';
+ if (defined($blosxom::version)) {
+ s/\$/$/g;
+ }
+ }
+
+
+ # Do the angle bracket song and dance:
+ s! < !<!gx;
+ s! > !>!gx;
+
+ # Now, escape characters that are magic in Markdown:
+ s! \* !$g_escape_table{'*'}!gx;
+ s! _ !$g_escape_table{'_'}!gx;
+ s! { !$g_escape_table{'{'}!gx;
+ s! } !$g_escape_table{'}'}!gx;
+ s! \[ !$g_escape_table{'['}!gx;
+ s! \] !$g_escape_table{']'}!gx;
+ s! \\ !$g_escape_table{'\\'}!gx;
+
+ return $_;
+}
+
+
+sub _DoItalicsAndBold {
+ my $text = shift;
+
+ # <strong> must go first:
+ $text =~ s{ (\*\*|__) (?=\S) (.+?[*_]*) (?<=\S) \1 }
+ {<strong>$2</strong>}gsx;
+
+ $text =~ s{ (\*|_) (?=\S) (.+?) (?<=\S) \1 }
+ {<em>$2</em>}gsx;
+
+ return $text;
+}
+
+
+sub _DoBlockQuotes {
+ my $text = shift;
+
+ $text =~ s{
+ ( # Wrap whole match in $1
+ (
+ ^[ \t]*>[ \t]? # '>' at the start of a line
+ .+\n # rest of the first line
+ (.+\n)* # subsequent consecutive lines
+ \n* # blanks
+ )+
+ )
+ }{
+ my $bq = $1;
+ $bq =~ s/^[ \t]*>[ \t]?//gm; # trim one level of quoting
+ $bq =~ s/^[ \t]+$//mg; # trim whitespace-only lines
+ $bq = _RunBlockGamut($bq); # recurse
+
+ $bq =~ s/^/ /g;
+ # These leading spaces screw with <pre> content, so we need to fix that:
+ $bq =~ s{
+ (\s*<pre>.+?</pre>)
+ }{
+ my $pre = $1;
+ $pre =~ s/^ //mg;
+ $pre;
+ }egsx;
+
+ "<blockquote>\n$bq\n</blockquote>\n\n";
+ }egmx;
+
+
+ return $text;
+}
+
+
+sub _FormParagraphs {
+#
+# Params:
+# $text - string to process with html <p> tags
+#
+ my $text = shift;
+
+ # Strip leading and trailing lines:
+ $text =~ s/\A\n+//;
+ $text =~ s/\n+\z//;
+
+ my @grafs = split(/\n{2,}/, $text);
+
+ #
+ # Wrap <p> tags.
+ #
+ foreach (@grafs) {
+ unless (defined( $g_html_blocks{$_} )) {
+ $_ = _RunSpanGamut($_);
+ s/^([ \t]*)/<p>/;
+ $_ .= "</p>";
+ }
+ }
+
+ #
+ # Unhashify HTML blocks
+ #
+ foreach (@grafs) {
+ if (defined( $g_html_blocks{$_} )) {
+ $_ = $g_html_blocks{$_};
+ }
+ }
+
+ return join "\n\n", @grafs;
+}
+
+
+sub _EncodeAmpsAndAngles {
+# Smart processing for ampersands and angle brackets that need to be encoded.
+
+ my $text = shift;
+
+ # Ampersand-encoding based entirely on Nat Irons's Amputator MT plugin:
+ # http://bumppo.net/projects/amputator/
+ $text =~ s/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/&/g;
+
+ # Encode naked <'s
+ $text =~ s{<(?![a-z/?\$!])}{<}gi;
+
+ return $text;
+}
+
+
+sub _EncodeBackslashEscapes {
+#
+# Parameter: String.
+# Returns: The string, with after processing the following backslash
+# escape sequences.
+#
+ local $_ = shift;
+
+ s! \\\\ !$g_escape_table{'\\'}!gx; # Must process escaped backslashes first.
+ s! \\` !$g_escape_table{'`'}!gx;
+ s! \\\* !$g_escape_table{'*'}!gx;
+ s! \\_ !$g_escape_table{'_'}!gx;
+ s! \\\{ !$g_escape_table{'{'}!gx;
+ s! \\\} !$g_escape_table{'}'}!gx;
+ s! \\\[ !$g_escape_table{'['}!gx;
+ s! \\\] !$g_escape_table{']'}!gx;
+ s! \\\( !$g_escape_table{'('}!gx;
+ s! \\\) !$g_escape_table{')'}!gx;
+ s! \\> !$g_escape_table{'>'}!gx;
+ s! \\\# !$g_escape_table{'#'}!gx;
+ s! \\\+ !$g_escape_table{'+'}!gx;
+ s! \\\- !$g_escape_table{'-'}!gx;
+ s! \\\. !$g_escape_table{'.'}!gx;
+ s{ \\! }{$g_escape_table{'!'}}gx;
+
+ return $_;
+}
+
+
+sub _DoAutoLinks {
+ my $text = shift;
+
+ $text =~ s{<((https?|ftp):[^'">\s]+)>}{<a href="$1">$1</a>}gi;
+
+ # Email addresses: <address@domain.foo>
+ $text =~ s{
+ <
+ (?:mailto:)?
+ (
+ [-.\w]+
+ \@
+ [-a-z0-9]+(\.[-a-z0-9]+)*\.[a-z]+
+ )
+ >
+ }{
+ _EncodeEmailAddress( _UnescapeSpecialChars($1) );
+ }egix;
+
+ return $text;
+}
+
+
+sub _EncodeEmailAddress {
+#
+# Input: an email address, e.g. "foo@example.com"
+#
+# Output: the email address as a mailto link, with each character
+# of the address encoded as either a decimal or hex entity, in
+# the hopes of foiling most address harvesting spam bots. E.g.:
+#
+# <a href="mailto:foo@e
+# xample.com">foo
+# @example.com</a>
+#
+# Based on a filter by Matthew Wickline, posted to the BBEdit-Talk
+# mailing list: <http://tinyurl.com/yu7ue>
+#
+
+ my $addr = shift;
+
+ srand;
+ my @encode = (
+ sub { '&#' . ord(shift) . ';' },
+ sub { '&#x' . sprintf( "%X", ord(shift) ) . ';' },
+ sub { shift },
+ );
+
+ $addr = "mailto:" . $addr;
+
+ $addr =~ s{(.)}{
+ my $char = $1;
+ if ( $char eq '@' ) {
+ # this *must* be encoded. I insist.
+ $char = $encode[int rand 1]->($char);
+ } elsif ( $char ne ':' ) {
+ # leave ':' alone (to spot mailto: later)
+ my $r = rand;
+ # roughly 10% raw, 45% hex, 45% dec
+ $char = (
+ $r > .9 ? $encode[2]->($char) :
+ $r < .45 ? $encode[1]->($char) :
+ $encode[0]->($char)
+ );
+ }
+ $char;
+ }gex;
+
+ $addr = qq{<a href="$addr">$addr</a>};
+ $addr =~ s{">.+?:}{">}; # strip the mailto: from the visible part
+
+ return $addr;
+}
+
+
+sub _UnescapeSpecialChars {
+#
+# Swap back in all the special characters we've hidden.
+#
+ my $text = shift;
+
+ while( my($char, $hash) = each(%g_escape_table) ) {
+ $text =~ s/$hash/$char/g;
+ }
+ return $text;
+}
+
+
+sub _TokenizeHTML {
+#
+# Parameter: String containing HTML markup.
+# Returns: Reference to an array of the tokens comprising the input
+# string. Each token is either a tag (possibly with nested,
+# tags contained therein, such as <a href="<MTFoo>">, or a
+# run of text between tags. Each element of the array is a
+# two-element array; the first is either 'tag' or 'text';
+# the second is the actual value.
+#
+#
+# Derived from the _tokenize() subroutine from Brad Choate's MTRegex plugin.
+# <http://www.bradchoate.com/past/mtregex.php>
+#
+
+ my $str = shift;
+ my $pos = 0;
+ my $len = length $str;
+ my @tokens;
+
+ my $depth = 6;
+ my $nested_tags = join('|', ('(?:<[a-z/!$](?:[^<>]') x $depth) . (')*>)' x $depth);
+ my $match = qr/(?s: <! ( -- .*? -- \s* )+ > ) | # comment
+ (?s: <\? .*? \?> ) | # processing instruction
+ $nested_tags/ix; # nested tags
+
+ while ($str =~ m/($match)/g) {
+ my $whole_tag = $1;
+ my $sec_start = pos $str;
+ my $tag_start = $sec_start - length $whole_tag;
+ if ($pos < $tag_start) {
+ push @tokens, ['text', substr($str, $pos, $tag_start - $pos)];
+ }
+ push @tokens, ['tag', $whole_tag];
+ $pos = pos $str;
+ }
+ push @tokens, ['text', substr($str, $pos, $len - $pos)] if $pos < $len;
+ \@tokens;
+}
+
+
+sub _Outdent {
+#
+# Remove one level of line-leading tabs or spaces
+#
+ my $text = shift;
+
+ $text =~ s/^(\t|[ ]{1,$g_tab_width})//gm;
+ return $text;
+}
+
+
+sub _Detab {
+#
+# Cribbed from a post by Bart Lateur:
+# <http://www.nntp.perl.org/group/perl.macperl.anyperl/154>
+#
+ my $text = shift;
+
+ $text =~ s{(.*?)\t}{$1.(' ' x ($g_tab_width - length($1) % $g_tab_width))}ge;
+ return $text;
+}
+
+
+1;
+
+__END__
+
+
+=pod
+
+=head1 NAME
+
+B<Markdown>
+
+
+=head1 SYNOPSIS
+
+B<Markdown.pl> [ B<--html4tags> ] [ B<--version> ] [ B<-shortversion> ]
+ [ I<file> ... ]
+
+
+=head1 DESCRIPTION
+
+Markdown is a text-to-HTML filter; it translates an easy-to-read /
+easy-to-write structured text format into HTML. Markdown's text format
+is most similar to that of plain text email, and supports features such
+as headers, *emphasis*, code blocks, blockquotes, and links.
+
+Markdown's syntax is designed not as a generic markup language, but
+specifically to serve as a front-end to (X)HTML. You can use span-level
+HTML tags anywhere in a Markdown document, and you can use block level
+HTML tags (like <div> and <table> as well).
+
+For more information about Markdown's syntax, see:
+
+ http://daringfireball.net/projects/markdown/
+
+
+=head1 OPTIONS
+
+Use "--" to end switch parsing. For example, to open a file named "-z", use:
+
+ Markdown.pl -- -z
+
+=over 4
+
+
+=item B<--html4tags>
+
+Use HTML 4 style for empty element tags, e.g.:
+
+ <br>
+
+instead of Markdown's default XHTML style tags, e.g.:
+
+ <br />
+
+
+=item B<-v>, B<--version>
+
+Display Markdown's version number and copyright information.
+
+
+=item B<-s>, B<--shortversion>
+
+Display the short-form version number.
+
+
+=back
+
+
+
+=head1 BUGS
+
+To file bug reports or feature requests (other than topics listed in the
+Caveats section above) please send email to:
+
+ support@daringfireball.net
+
+Please include with your report: (1) the example input; (2) the output
+you expected; (3) the output Markdown actually produced.
+
+
+=head1 VERSION HISTORY
+
+See the readme file for detailed release notes for this version.
+
+1.0.1 - 14 Dec 2004
+
+1.0 - 28 Aug 2004
+
+
+=head1 AUTHOR
+
+ John Gruber
+ http://daringfireball.net
+
+ PHP port and other contributions by Michel Fortin
+ http://michelf.com
+
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (c) 2003-2004 John Gruber
+<http://daringfireball.net/>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+* Neither the name "Markdown" nor the names of its contributors may
+ be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+This software is provided by the copyright holders and contributors "as
+is" and any express or implied warranties, including, but not limited
+to, the implied warranties of merchantability and fitness for a
+particular purpose are disclaimed. In no event shall the copyright owner
+or contributors be liable for any direct, indirect, incidental, special,
+exemplary, or consequential damages (including, but not limited to,
+procurement of substitute goods or services; loss of use, data, or
+profits; or business interruption) however caused and on any theory of
+liability, whether in contract, strict liability, or tort (including
+negligence or otherwise) arising in any way out of the use of this
+software, even if advised of the possibility of such damage.
+
+=cut
--- /dev/null
+-------------------------------------------------------------------------------
+ Fence support:
+-------------------------------------------------------------------------------
+
+Fences provide a few new modification order constraints as well as an
+interesting extension to release sequences, detailed in 29.3 (p4-p7) and 29.8
+(p2-p4). The specifications are pasted here in Appendix A and are applied to our
+model-checker in these notes.
+
+Section 29.3 details the modification order constraints established by
+sequentially-consistent fences.
+
+Section 29.8 details the behavior of release and acquire fences (note that
+memory_order_seq_cst is both release and acquire).
+
+The text of these rules are provided at the end of this document for reference.
+
+*******************************
+ Backtracking requirements
+*******************************
+
+Because we maintain the seq-cst order as consistent with the execution order,
+seq-cst fences cannot commute with each other, with seq-cst loads, nor with
+seq-cst stores; we backtrack at all such pairs.
+
+Fences extend release/acquire synchronization beyond just
+store-release/load-acquire. We must backtrack with potentially-synchronizing
+fences: that is, with any pair of store- or fence-release and load- or
+fence-acquire, where the release comes after the acquire in the execution order
+(the other ordering is OK, as we will explore both behaviors; where the pair
+synchronize and where they don't).
+
+Note that, for instance, a fence-release may synchronize with a fence-acquire
+only in the presence of a appropriate load/store pair (29.8p2); but the
+synchronization still occurs between the fences, so the backtracking
+requirements are only placed on the release/acquire fences themselves.
+
+*******************************
+ Seq-cst MO constraints (29.3 p4-p7)
+*******************************
+
+The statements given in the specification regarding sequentially consistent
+fences can be transformed into the following 4 modification order constraints.
+
+29.3p4
+
+If
+ is_write(A) && is_read(B) && is_write(W) && is_fence(X) &&
+ is_seqcst(W) && is_seqcst(X) && A != W &&
+ same_loc(W, A, B) &&
+ A --rf-> B &&
+ W --sc-> X --sb-> B
+then
+ W --mo-> A
+
+Intuition/Implementation:
+ * We may (but don't currently) limit our considertion of W to only the most
+ recent (in the SC order) store to the same location as A and B prior to X
+ (note that all prior writes will be ordered prior to W in both SC and MO)
+ * We should consider the "most recent" seq-cst fence X that precedes B
+ * This search can be combined with the r_modification_order search, since we
+ already iterate through the necessary stores W
+
+29.3p5
+
+If
+ is_write(A) && is_read(B) && is_write(W) && is_fence(X) &&
+ is_seqcst(B) && is_seqcst(X) &&
+ same_loc(W, A, B) &&
+ A != W &&
+ A --rf-> B &&
+ W --sb-> X --sc-> B
+then
+ W --mo-> A
+
+Intuition/Implementation:
+ * We only need to examine the "most recent" seq-cst fence X from each thread
+ * We only need to examine the "most recent" qualifying store W that precedes X;
+ all other W will provide a weaker MO constraint
+ * This search can be combined with the r_modification_order search, since we
+ already iterate through the necessary stores W
+
+29.3p6
+
+If
+ is_write(A) && is_read(B) && is_write(W) && is_fence(X) && is_fence(Y) &&
+ is_seqcst(X) && is_seqcst(Y) &&
+ same_loc(W, A, B) &&
+ A != W &&
+ A --rf-> B &&
+ W --sb-> X --sc-> Y --sb-> B
+then
+ W --mo-> A
+
+Intuition/Implementation:
+ * We should consider only the "most recent" fence Y in the same thread as B
+ (prior fences may only yield the same or weaker constraints)
+ * We may then consider the "most recent" seq-cst fence X prior to Y (in SC order)
+ from each thread (prior fences may only yield the same or weaker constraints)
+ * We should consider only the "most recent" store W (to the same location as A,
+ B) in the same thread as X (prior stores may only yield the same or weaker
+ constraints)
+ * This search can be combined with the r_modification_order search, since we
+ already iterate through the necessary stores W
+
+29.3p7
+
+If
+ is_write(A) && is_write(B) && is_fence(X) && is_fence(Y) &&
+ is_seqcst(X) && is_seqcst(Y) &&
+ same_loc(A, B) &&
+ A --sb-> X --sc-> Y --sb-> B
+then
+ A --mo-> B
+
+Intuition/Implementation:
+ * (Similar to 29.3p6 rules, except using A/B write/write) only search for the
+ most recent fence Y in the same thread; search for the most recent (prior to
+ Y) fence X from each thread; search for the most recent store A prior to X
+ * This search can be combined with the w_modification_order search, since we
+ already iterate through the necessary stores A
+
+**********************************************************************
+ Release/acquire synchronization: extended to fences (29.3 p4-p7)
+**********************************************************************
+
+The C++ specification statements regarding release and acquire fences make
+extensions to release sequences, using what they call "hypothetical release
+sequences." These hypothetical release sequences are the same as normal release
+sequences, except that the "head" doesn't have to be a release: it can have any
+memory order (e.g., relaxed). This change actually simplifies our release
+sequences (for the fence case), as we don't actually have to establish a
+contiguous modification order all the way to a release operation; we just need
+to reach the same thread (via a RMW chain, for instance).
+
+The statements given in the specification regarding release and acquire fences
+do not result in totally separable conditions, so I will write down my
+semi-formal notation here along with some simple notes then present my
+implementation notes at the end.
+
+Note that we will use A --rs-> B to denote that B is in the release sequence
+headed by A (we allow A = B, unless otherwise stated). The hypothetical release
+sequence will be similarly denoted A --hrs-> B.
+
+29.8p2
+
+If
+ is_fence(A) && is_write(X) && is_write(W) && is_read(Y) && is_fence(B) &&
+ is_release(A) && is_acquire(B) &&
+ A --sb-> X --hrs-> W --rf-> Y --sb-> B
+then
+ A --sw-> B
+
+Notes:
+ * The fence-release A does not result in any action on its own (i.e., when it
+ is first explored); it only affects later release operations, at which point
+ we may need to associate store X with A. Thus, for every store X, we eagerly
+ record the most recent fence-release, then this record can be utilized during
+ later (hypothetical) release sequence checks.
+ * The fence-acquire B is more troublesome, since there may be many qualifying
+ loads Y (loads from different locations; loads which read from different
+ threads; etc.). Each Y may read from different hypothetical release
+ sequences, ending in a different release A with which B should synchronize.
+ It is difficult (but not impossible) to find good stopping conditions at
+ which we should terminate our search for Y. However, we at least know we only
+ need to consder Y such that:
+ V --sb-> Y --sb-> B
+ where V is a previous fence-acquire.
+
+29.8p3
+
+If
+ is_fence(A) && is_write(X) && is_write(W) && is_read(B) &&
+ is_release(A) && is_acquire(B) &&
+ A --sb-> X --hrs-> W --rf-> B
+then
+ A --sw-> B
+
+Notes:
+ * See the note for fence-release A in 29.8p2
+
+29.8p4
+
+If
+ is_write(A) && is_write(W) && is_read(X) && is_fence(B) &&
+ is_release(A) && is_acquire(B) &&
+ A --rs-> W --rf-> X --sb-> B
+then
+ A --sw-> B
+
+Notes:
+ * See the note for fence-acquire B in 29.8p2. The A, Y, and B in 29.8p2
+ correspond to A, X, and B in this rule (29.8p4).
+
+Summary notes:
+
+Now, noting the overlap in implementation notes between 29.8p2,3,4 and the
+similarity between release sequences and hypothetical release sequences, I can
+extend our release sequence support to provide easy facilities for
+release/acquire fence support.
+
+I extend release sequence support to include fences first by distinguishing the
+'acquire' from the 'load'; previously, release sequence searches were always
+triggered by a load-acquire operation. Now, we may have a *fence*-acquire which
+finds a previous load-*relaxed*, then follows any chain to a release sequence
+(29.8p4). Any release heads found by our existing release sequence support must
+synchronize with the fence-acquire. Any uncertain release sequences can be
+stashed (along with both the fence-acquire and the load-relaxed) as "pending" in
+the existing lists.
+
+Next I extend the release sequence support to include hypothetical release
+sequences. Note that any search for a release sequence can also search for a
+hypothetical release sequence with little additional effort (and even saving
+effort in cases where a fence-release hides a prior store-release, whose release
+sequence may be harder to establish eagerly). Because the "most recent"
+fence-release is stashed in each ModelAction (see the fence-release note in
+29.8p2), release sequence searches can easily add the most recent fence-release
+to the release_heads vector as it explores a RMW chain. Then, once it reaches a
+thread in which it looks for a store-release, it can perform this interesting
+optimization: if the most recent store-release is sequenced before the most
+recent fence-release, then we can ignore the store-release and simply
+synchronize with the fence-release. This avoids a "contiguous MO" computation.
+
+So, with hypothetical release sequences seamlessly integrated into the release
+sequence code, we easily cover 29.8p3 (fence-release --sw-> load-acquire). Then,
+it's a simple extension to see how 29.8p2 is just a combination of the rules
+described for 29.8p3 and 29.8p4: a fence-acquire triggers a search for loads in
+its same thread; these loads then launch a series of release sequence
+searches--hypothetical (29.8p2) or real (29.8p4)--and synchronizes with all the
+release heads.
+
+The best part about all of the preceding explanations: the lazy fixups, etc.,
+can simply be re-used from existing release sequence code, with slight
+adjustments for dealing the presence of a fence-acquire preceded by a
+load-relaxed.
+
+*******************************
+ Miscellaneous Notes
+*******************************
+
+fence(memory_order_consume) acts like memory_order_release, so if we ever
+support consume, we must alias consume -> release
+
+fence(memory_order_relaxed) is a no-op
+
+**************************************************
+ Appendix A: From the C++11 specification (N3337)
+**************************************************
+
+-------------
+Section 29.3
+-------------
+
+29.3p4
+
+For an atomic operation B that reads the value of an atomic object M, if there
+is a memory_order_seq_cst fence X sequenced before B, then B observes either
+the last memory_order_seq_cst modification of M preceding X in the total order
+S or a later modification of M in its modification order.
+
+29.3p5
+
+For atomic operations A and B on an atomic object M, where A modifies M and B
+takes its value, if there is a memory_order_seq_cst fence X such that A is
+sequenced before X and B follows X in S, then B observes either the effects of
+A or a later modification of M in its modification order.
+
+29.3p6
+
+For atomic operations A and B on an atomic object M, where A modifies M and B
+takes its value, if there are memory_order_seq_cst fences X and Y such that A
+is sequenced before X, Y is sequenced before B, and X precedes Y in S, then B
+observes either the effects of A or a later modification of M in its
+modification order.
+
+29.3p7
+
+For atomic operations A and B on an atomic object M, if there are
+memory_order_seq_cst fences X and Y such that A is sequenced before X, Y is
+sequenced before B, and X precedes Y in S, then B occurs later than A in the
+modification order of M.
+
+-------------
+Section 29.8
+-------------
+
+29.8p2
+
+A release fence A synchronizes with an acquire fence B if there exist atomic
+operations X and Y, both operating on some atomic object M, such that A is
+sequenced before X, X modifies M, Y is sequenced before B, and Y reads the value
+written by X or a value written by any side effect in the hypothetical release
+sequence X would head if it were a release operation.
+
+29.8p3
+
+A release fence A synchronizes with an atomic operation B that performs an
+acquire operation on an atomic object M if there exists an atomic operation X
+such that A is sequenced before X, X modifies M, and B reads the value written
+by X or a value written by any side effect in the hypothetical release sequence
+X would head if it were a release operation.
+
+29.8p4
+
+An atomic operation A that is a release operation on an atomic object M
+synchronizes with an acquire fence B if there exists some atomic operation X on
+M such that X is sequenced before B and reads the value written by A or a value
+written by any side effect in the release sequence headed by A.
--- /dev/null
+-------------------------------------------------------------------------------
+ Release sequence support:
+-------------------------------------------------------------------------------
+
+*******************************
+ From the C++11 specification
+*******************************
+
+1.10.7
+
+A release sequence from a release operation A on an atomic object M is a
+maximal contiguous sub-sequence of side effects in the modification order of
+M, where the first operation is A, and every subsequent operation
+
+- is performed by the same thread that performed A, or
+- is an atomic read-modify-write operation.
+
+29.3.2
+
+An atomic operation A that performs a release operation on an atomic object M
+synchronizes with an atomic operation B that performs an acquire operation on
+M and takes its value from any side effect in the release sequence headed by
+A.
+
+*******************************
+ My Notes
+*******************************
+
+The specification allows for a single acquire to synchronize with more than
+one release operation, as its "reads from" value might be part of more than
+one release sequence.
+
+*******************************
+ Approximate Algorithm
+*******************************
+
+Check read-write chain...
+
+Given:
+current action = curr
+read from = rf
+Cases:
+* rf is NULL: return uncertain
+* rf is RMW:
+ - if rf is release:
+ add rf to release heads
+ - if rf is rel_acq:
+ return certain [note: we don't need to extend release sequence
+ further because this acquire will have synchronized already]
+ else
+ return (recursively) "get release sequence head of rf"
+* if rf is release:
+ add rf to release heads
+ return certain
+* else, rf is relaxed write (NOT RMW)
+ - check same thread
+
+*******************************
+"check same thread"
+*******************************
+
+let release = max{act in S | samethread(act, rf) && isrelease(act) && act <= rf}
+let t = thread(rf) // == thread(release)
+for all threads t_j != t
+ if exists c in S | c !--mo--> release, rf !--mo--> c, c is write, thread(c) == t_j then
+ return certain;
+[ note: need to check "future ordered" condition ]
+add release to release heads
+return certain;
+
+*******************************
+General fixup steps:
+*******************************
+
+1. process action, find read_from
+2. add initial mo_graph edges
+3. assign read_from, calc initial "get_release_seq_heads()"
+4. perform synchronization with all release heads
+
+synchronization => check for new mo_graph edges
+ => check for resolved release sequences
+ => check for failed promises
+mo_graph edges => check for resolved release sequences
+
+*******************************
+Other notes
+*******************************
+
+"cannot determine" means we need to lazily check conditions in the future
+ - check when future writes satisfy "promises"
+
+Read from future? We require that all release heads are "in the past", so that
+we don't form synchronization against the ordering of the program trace. We
+ensure that some execution is explored in which they are ordered the other way,
+so we declare this execution "infeasible."
+
+=> If we *do* establish a synchronization after the fact:
+ - need to recurse through the execution trace and update clock vectors
+ - more
--- /dev/null
+#include <stdio.h>
+#include <algorithm>
+#include <mutex>
+#include <new>
+#include <stdarg.h>
+
+#include "model.h"
+#include "execution.h"
+#include "action.h"
+#include "nodestack.h"
+#include "schedule.h"
+#include "common.h"
+#include "clockvector.h"
+#include "cyclegraph.h"
+#include "promise.h"
+#include "datarace.h"
+#include "threads-model.h"
+#include "bugmessage.h"
+
+#define INITIAL_THREAD_ID 0
+
+/**
+ * Structure for holding small ModelChecker members that should be snapshotted
+ */
+struct model_snapshot_members {
+ model_snapshot_members() :
+ /* First thread created will have id INITIAL_THREAD_ID */
+ next_thread_id(INITIAL_THREAD_ID),
+ used_sequence_numbers(0),
+ next_backtrack(NULL),
+ bugs(),
+ failed_promise(false),
+ too_many_reads(false),
+ no_valid_reads(false),
+ bad_synchronization(false),
+ asserted(false)
+ { }
+
+ ~model_snapshot_members() {
+ for (unsigned int i = 0; i < bugs.size(); i++)
+ delete bugs[i];
+ bugs.clear();
+ }
+
+ unsigned int next_thread_id;
+ modelclock_t used_sequence_numbers;
+ ModelAction *next_backtrack;
+ SnapVector<bug_message *> bugs;
+ bool failed_promise;
+ bool too_many_reads;
+ bool no_valid_reads;
+ /** @brief Incorrectly-ordered synchronization was made */
+ bool bad_synchronization;
+ bool asserted;
+
+ SNAPSHOTALLOC
+};
+
+/** @brief Constructor */
+ModelExecution::ModelExecution(ModelChecker *m,
+ const struct model_params *params,
+ Scheduler *scheduler,
+ NodeStack *node_stack) :
+ model(m),
+ params(params),
+ scheduler(scheduler),
+ action_trace(),
+ thread_map(2), /* We'll always need at least 2 threads */
+ obj_map(),
+ condvar_waiters_map(),
+ obj_thrd_map(),
+ promises(),
+ futurevalues(),
+ pending_rel_seqs(),
+ thrd_last_action(1),
+ thrd_last_fence_release(),
+ node_stack(node_stack),
+ priv(new struct model_snapshot_members()),
+ mo_graph(new CycleGraph())
+{
+ /* Initialize a model-checker thread, for special ModelActions */
+ model_thread = new Thread(get_next_id());
+ add_thread(model_thread);
+ scheduler->register_engine(this);
+ node_stack->register_engine(this);
+}
+
+/** @brief Destructor */
+ModelExecution::~ModelExecution()
+{
+ for (unsigned int i = 0; i < get_num_threads(); i++)
+ delete get_thread(int_to_id(i));
+
+ for (unsigned int i = 0; i < promises.size(); i++)
+ delete promises[i];
+
+ delete mo_graph;
+ delete priv;
+}
+
+int ModelExecution::get_execution_number() const
+{
+ return model->get_execution_number();
+}
+
+static action_list_t * get_safe_ptr_action(HashTable<const void *, action_list_t *, uintptr_t, 4> * hash, void * ptr)
+{
+ action_list_t *tmp = hash->get(ptr);
+ if (tmp == NULL) {
+ tmp = new action_list_t();
+ hash->put(ptr, tmp);
+ }
+ return tmp;
+}
+
+static SnapVector<action_list_t> * get_safe_ptr_vect_action(HashTable<void *, SnapVector<action_list_t> *, uintptr_t, 4> * hash, void * ptr)
+{
+ SnapVector<action_list_t> *tmp = hash->get(ptr);
+ if (tmp == NULL) {
+ tmp = new SnapVector<action_list_t>();
+ hash->put(ptr, tmp);
+ }
+ return tmp;
+}
+
+action_list_t * ModelExecution::get_actions_on_obj(void * obj, thread_id_t tid) const
+{
+ SnapVector<action_list_t> *wrv = obj_thrd_map.get(obj);
+ if (wrv==NULL)
+ return NULL;
+ unsigned int thread=id_to_int(tid);
+ if (thread < wrv->size())
+ return &(*wrv)[thread];
+ else
+ return NULL;
+}
+
+/** @return a thread ID for a new Thread */
+thread_id_t ModelExecution::get_next_id()
+{
+ return priv->next_thread_id++;
+}
+
+/** @return the number of user threads created during this execution */
+unsigned int ModelExecution::get_num_threads() const
+{
+ return priv->next_thread_id;
+}
+
+/** @return a sequence number for a new ModelAction */
+modelclock_t ModelExecution::get_next_seq_num()
+{
+ return ++priv->used_sequence_numbers;
+}
+
+/**
+ * @brief Should the current action wake up a given thread?
+ *
+ * @param curr The current action
+ * @param thread The thread that we might wake up
+ * @return True, if we should wake up the sleeping thread; false otherwise
+ */
+bool ModelExecution::should_wake_up(const ModelAction *curr, const Thread *thread) const
+{
+ const ModelAction *asleep = thread->get_pending();
+ /* Don't allow partial RMW to wake anyone up */
+ if (curr->is_rmwr())
+ return false;
+ /* Synchronizing actions may have been backtracked */
+ if (asleep->could_synchronize_with(curr))
+ return true;
+ /* All acquire/release fences and fence-acquire/store-release */
+ if (asleep->is_fence() && asleep->is_acquire() && curr->is_release())
+ return true;
+ /* Fence-release + store can awake load-acquire on the same location */
+ if (asleep->is_read() && asleep->is_acquire() && curr->same_var(asleep) && curr->is_write()) {
+ ModelAction *fence_release = get_last_fence_release(curr->get_tid());
+ if (fence_release && *(get_last_action(thread->get_id())) < *fence_release)
+ return true;
+ }
+ return false;
+}
+
+void ModelExecution::wake_up_sleeping_actions(ModelAction *curr)
+{
+ for (unsigned int i = 0; i < get_num_threads(); i++) {
+ Thread *thr = get_thread(int_to_id(i));
+ if (scheduler->is_sleep_set(thr)) {
+ if (should_wake_up(curr, thr))
+ /* Remove this thread from sleep set */
+ scheduler->remove_sleep(thr);
+ }
+ }
+}
+
+/** @brief Alert the model-checker that an incorrectly-ordered
+ * synchronization was made */
+void ModelExecution::set_bad_synchronization()
+{
+ priv->bad_synchronization = true;
+}
+
+bool ModelExecution::assert_bug(const char *msg)
+{
+ priv->bugs.push_back(new bug_message(msg));
+
+ if (isfeasibleprefix()) {
+ set_assert();
+ return true;
+ }
+ return false;
+}
+
+/** @return True, if any bugs have been reported for this execution */
+bool ModelExecution::have_bug_reports() const
+{
+ return priv->bugs.size() != 0;
+}
+
+SnapVector<bug_message *> * ModelExecution::get_bugs() const
+{
+ return &priv->bugs;
+}
+
+/**
+ * Check whether the current trace has triggered an assertion which should halt
+ * its execution.
+ *
+ * @return True, if the execution should be aborted; false otherwise
+ */
+bool ModelExecution::has_asserted() const
+{
+ return priv->asserted;
+}
+
+/**
+ * Trigger a trace assertion which should cause this execution to be halted.
+ * This can be due to a detected bug or due to an infeasibility that should
+ * halt ASAP.
+ */
+void ModelExecution::set_assert()
+{
+ priv->asserted = true;
+}
+
+/**
+ * Check if we are in a deadlock. Should only be called at the end of an
+ * execution, although it should not give false positives in the middle of an
+ * execution (there should be some ENABLED thread).
+ *
+ * @return True if program is in a deadlock; false otherwise
+ */
+bool ModelExecution::is_deadlocked() const
+{
+ bool blocking_threads = false;
+ for (unsigned int i = 0; i < get_num_threads(); i++) {
+ thread_id_t tid = int_to_id(i);
+ if (is_enabled(tid))
+ return false;
+ Thread *t = get_thread(tid);
+ if (!t->is_model_thread() && t->get_pending())
+ blocking_threads = true;
+ }
+ return blocking_threads;
+}
+
+/**
+ * @brief Check if we are yield-blocked
+ *
+ * A program can be "yield-blocked" if all threads are ready to execute a
+ * yield.
+ *
+ * @return True if the program is yield-blocked; false otherwise
+ */
+bool ModelExecution::is_yieldblocked() const
+{
+ if (!params->yieldblock)
+ return false;
+
+ for (unsigned int i = 0; i < get_num_threads(); i++) {
+ thread_id_t tid = int_to_id(i);
+ Thread *t = get_thread(tid);
+ if (t->get_pending() && t->get_pending()->is_yield())
+ return true;
+ }
+ return false;
+}
+
+/**
+ * Check if this is a complete execution. That is, have all thread completed
+ * execution (rather than exiting because sleep sets have forced a redundant
+ * execution).
+ *
+ * @return True if the execution is complete.
+ */
+bool ModelExecution::is_complete_execution() const
+{
+ if (is_yieldblocked())
+ return false;
+ for (unsigned int i = 0; i < get_num_threads(); i++)
+ if (is_enabled(int_to_id(i)))
+ return false;
+ return true;
+}
+
+/**
+ * @brief Find the last fence-related backtracking conflict for a ModelAction
+ *
+ * This function performs the search for the most recent conflicting action
+ * against which we should perform backtracking, as affected by fence
+ * operations. This includes pairs of potentially-synchronizing actions which
+ * occur due to fence-acquire or fence-release, and hence should be explored in
+ * the opposite execution order.
+ *
+ * @param act The current action
+ * @return The most recent action which conflicts with act due to fences
+ */
+ModelAction * ModelExecution::get_last_fence_conflict(ModelAction *act) const
+{
+ /* Only perform release/acquire fence backtracking for stores */
+ if (!act->is_write())
+ return NULL;
+
+ /* Find a fence-release (or, act is a release) */
+ ModelAction *last_release;
+ if (act->is_release())
+ last_release = act;
+ else
+ last_release = get_last_fence_release(act->get_tid());
+ if (!last_release)
+ return NULL;
+
+ /* Skip past the release */
+ const action_list_t *list = &action_trace;
+ action_list_t::const_reverse_iterator rit;
+ for (rit = list->rbegin(); rit != list->rend(); rit++)
+ if (*rit == last_release)
+ break;
+ ASSERT(rit != list->rend());
+
+ /* Find a prior:
+ * load-acquire
+ * or
+ * load --sb-> fence-acquire */
+ ModelVector<ModelAction *> acquire_fences(get_num_threads(), NULL);
+ ModelVector<ModelAction *> prior_loads(get_num_threads(), NULL);
+ bool found_acquire_fences = false;
+ for ( ; rit != list->rend(); rit++) {
+ ModelAction *prev = *rit;
+ if (act->same_thread(prev))
+ continue;
+
+ int tid = id_to_int(prev->get_tid());
+
+ if (prev->is_read() && act->same_var(prev)) {
+ if (prev->is_acquire()) {
+ /* Found most recent load-acquire, don't need
+ * to search for more fences */
+ if (!found_acquire_fences)
+ return NULL;
+ } else {
+ prior_loads[tid] = prev;
+ }
+ }
+ if (prev->is_acquire() && prev->is_fence() && !acquire_fences[tid]) {
+ found_acquire_fences = true;
+ acquire_fences[tid] = prev;
+ }
+ }
+
+ ModelAction *latest_backtrack = NULL;
+ for (unsigned int i = 0; i < acquire_fences.size(); i++)
+ if (acquire_fences[i] && prior_loads[i])
+ if (!latest_backtrack || *latest_backtrack < *acquire_fences[i])
+ latest_backtrack = acquire_fences[i];
+ return latest_backtrack;
+}
+
+/**
+ * @brief Find the last backtracking conflict for a ModelAction
+ *
+ * This function performs the search for the most recent conflicting action
+ * against which we should perform backtracking. This primary includes pairs of
+ * synchronizing actions which should be explored in the opposite execution
+ * order.
+ *
+ * @param act The current action
+ * @return The most recent action which conflicts with act
+ */
+ModelAction * ModelExecution::get_last_conflict(ModelAction *act) const
+{
+ switch (act->get_type()) {
+ case ATOMIC_FENCE:
+ /* Only seq-cst fences can (directly) cause backtracking */
+ if (!act->is_seqcst())
+ break;
+ case ATOMIC_READ:
+ case ATOMIC_WRITE:
+ case ATOMIC_RMW: {
+ ModelAction *ret = NULL;
+
+ /* linear search: from most recent to oldest */
+ action_list_t *list = obj_map.get(act->get_location());
+ action_list_t::reverse_iterator rit;
+ for (rit = list->rbegin(); rit != list->rend(); rit++) {
+ ModelAction *prev = *rit;
+ if (prev == act)
+ continue;
+ if (prev->could_synchronize_with(act)) {
+ ret = prev;
+ break;
+ }
+ }
+
+ ModelAction *ret2 = get_last_fence_conflict(act);
+ if (!ret2)
+ return ret;
+ if (!ret)
+ return ret2;
+ if (*ret < *ret2)
+ return ret2;
+ return ret;
+ }
+ case ATOMIC_LOCK:
+ case ATOMIC_TRYLOCK: {
+ /* linear search: from most recent to oldest */
+ action_list_t *list = obj_map.get(act->get_location());
+ action_list_t::reverse_iterator rit;
+ for (rit = list->rbegin(); rit != list->rend(); rit++) {
+ ModelAction *prev = *rit;
+ if (act->is_conflicting_lock(prev))
+ return prev;
+ }
+ break;
+ }
+ case ATOMIC_UNLOCK: {
+ /* linear search: from most recent to oldest */
+ action_list_t *list = obj_map.get(act->get_location());
+ action_list_t::reverse_iterator rit;
+ for (rit = list->rbegin(); rit != list->rend(); rit++) {
+ ModelAction *prev = *rit;
+ if (!act->same_thread(prev) && prev->is_failed_trylock())
+ return prev;
+ }
+ break;
+ }
+ case ATOMIC_WAIT: {
+ /* linear search: from most recent to oldest */
+ action_list_t *list = obj_map.get(act->get_location());
+ action_list_t::reverse_iterator rit;
+ for (rit = list->rbegin(); rit != list->rend(); rit++) {
+ ModelAction *prev = *rit;
+ if (!act->same_thread(prev) && prev->is_failed_trylock())
+ return prev;
+ if (!act->same_thread(prev) && prev->is_notify())
+ return prev;
+ }
+ break;
+ }
+
+ case ATOMIC_NOTIFY_ALL:
+ case ATOMIC_NOTIFY_ONE: {
+ /* linear search: from most recent to oldest */
+ action_list_t *list = obj_map.get(act->get_location());
+ action_list_t::reverse_iterator rit;
+ for (rit = list->rbegin(); rit != list->rend(); rit++) {
+ ModelAction *prev = *rit;
+ if (!act->same_thread(prev) && prev->is_wait())
+ return prev;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ return NULL;
+}
+
+/** This method finds backtracking points where we should try to
+ * reorder the parameter ModelAction against.
+ *
+ * @param the ModelAction to find backtracking points for.
+ */
+void ModelExecution::set_backtracking(ModelAction *act)
+{
+ Thread *t = get_thread(act);
+ ModelAction *prev = get_last_conflict(act);
+ if (prev == NULL)
+ return;
+
+ Node *node = prev->get_node()->get_parent();
+
+ /* See Dynamic Partial Order Reduction (addendum), POPL '05 */
+ int low_tid, high_tid;
+ if (node->enabled_status(t->get_id()) == THREAD_ENABLED) {
+ low_tid = id_to_int(act->get_tid());
+ high_tid = low_tid + 1;
+ } else {
+ low_tid = 0;
+ high_tid = get_num_threads();
+ }
+
+ for (int i = low_tid; i < high_tid; i++) {
+ thread_id_t tid = int_to_id(i);
+
+ /* Make sure this thread can be enabled here. */
+ if (i >= node->get_num_threads())
+ break;
+
+ /* See Dynamic Partial Order Reduction (addendum), POPL '05 */
+ /* Don't backtrack into a point where the thread is disabled or sleeping. */
+ if (node->enabled_status(tid) != THREAD_ENABLED)
+ continue;
+
+ /* Check if this has been explored already */
+ if (node->has_been_explored(tid))
+ continue;
+
+ /* See if fairness allows */
+ if (params->fairwindow != 0 && !node->has_priority(tid)) {
+ bool unfair = false;
+ for (int t = 0; t < node->get_num_threads(); t++) {
+ thread_id_t tother = int_to_id(t);
+ if (node->is_enabled(tother) && node->has_priority(tother)) {
+ unfair = true;
+ break;
+ }
+ }
+ if (unfair)
+ continue;
+ }
+
+ /* See if CHESS-like yield fairness allows */
+ if (params->yieldon) {
+ bool unfair = false;
+ for (int t = 0; t < node->get_num_threads(); t++) {
+ thread_id_t tother = int_to_id(t);
+ if (node->is_enabled(tother) && node->has_priority_over(tid, tother)) {
+ unfair = true;
+ break;
+ }
+ }
+ if (unfair)
+ continue;
+ }
+
+ /* Cache the latest backtracking point */
+ set_latest_backtrack(prev);
+
+ /* If this is a new backtracking point, mark the tree */
+ if (!node->set_backtrack(tid))
+ continue;
+ DEBUG("Setting backtrack: conflict = %d, instead tid = %d\n",
+ id_to_int(prev->get_tid()),
+ id_to_int(t->get_id()));
+ if (DBG_ENABLED()) {
+ prev->print();
+ act->print();
+ }
+ }
+}
+
+/**
+ * @brief Cache the a backtracking point as the "most recent", if eligible
+ *
+ * Note that this does not prepare the NodeStack for this backtracking
+ * operation, it only caches the action on a per-execution basis
+ *
+ * @param act The operation at which we should explore a different next action
+ * (i.e., backtracking point)
+ * @return True, if this action is now the most recent backtracking point;
+ * false otherwise
+ */
+bool ModelExecution::set_latest_backtrack(ModelAction *act)
+{
+ if (!priv->next_backtrack || *act > *priv->next_backtrack) {
+ priv->next_backtrack = act;
+ return true;
+ }
+ return false;
+}
+
+/**
+ * Returns last backtracking point. The model checker will explore a different
+ * path for this point in the next execution.
+ * @return The ModelAction at which the next execution should diverge.
+ */
+ModelAction * ModelExecution::get_next_backtrack()
+{
+ ModelAction *next = priv->next_backtrack;
+ priv->next_backtrack = NULL;
+ return next;
+}
+
+/**
+ * Processes a read model action.
+ * @param curr is the read model action to process.
+ * @return True if processing this read updates the mo_graph.
+ */
+bool ModelExecution::process_read(ModelAction *curr)
+{
+ Node *node = curr->get_node();
+ while (true) {
+ bool updated = false;
+ switch (node->get_read_from_status()) {
+ case READ_FROM_PAST: {
+ const ModelAction *rf = node->get_read_from_past();
+ ASSERT(rf);
+
+ mo_graph->startChanges();
+
+ ASSERT(!is_infeasible());
+ if (!check_recency(curr, rf)) {
+ if (node->increment_read_from()) {
+ mo_graph->rollbackChanges();
+ continue;
+ } else {
+ priv->too_many_reads = true;
+ }
+ }
+
+ updated = r_modification_order(curr, rf);
+ read_from(curr, rf);
+ mo_graph->commitChanges();
+ mo_check_promises(curr, true);
+ break;
+ }
+ case READ_FROM_PROMISE: {
+ Promise *promise = curr->get_node()->get_read_from_promise();
+ if (promise->add_reader(curr))
+ priv->failed_promise = true;
+ curr->set_read_from_promise(promise);
+ mo_graph->startChanges();
+ if (!check_recency(curr, promise))
+ priv->too_many_reads = true;
+ updated = r_modification_order(curr, promise);
+ mo_graph->commitChanges();
+ break;
+ }
+ case READ_FROM_FUTURE: {
+ /* Read from future value */
+ struct future_value fv = node->get_future_value();
+ Promise *promise = new Promise(this, curr, fv);
+ curr->set_read_from_promise(promise);
+ promises.push_back(promise);
+ mo_graph->startChanges();
+ updated = r_modification_order(curr, promise);
+ mo_graph->commitChanges();
+ break;
+ }
+ default:
+ ASSERT(false);
+ }
+ get_thread(curr)->set_return_value(curr->get_return_value());
+ return updated;
+ }
+}
+
+/**
+ * Processes a lock, trylock, or unlock model action. @param curr is
+ * the read model action to process.
+ *
+ * The try lock operation checks whether the lock is taken. If not,
+ * it falls to the normal lock operation case. If so, it returns
+ * fail.
+ *
+ * The lock operation has already been checked that it is enabled, so
+ * it just grabs the lock and synchronizes with the previous unlock.
+ *
+ * The unlock operation has to re-enable all of the threads that are
+ * waiting on the lock.
+ *
+ * @return True if synchronization was updated; false otherwise
+ */
+bool ModelExecution::process_mutex(ModelAction *curr)
+{
+ std::mutex *mutex = curr->get_mutex();
+ struct std::mutex_state *state = NULL;
+
+ if (mutex)
+ state = mutex->get_state();
+
+ switch (curr->get_type()) {
+ case ATOMIC_TRYLOCK: {
+ bool success = !state->locked;
+ curr->set_try_lock(success);
+ if (!success) {
+ get_thread(curr)->set_return_value(0);
+ break;
+ }
+ get_thread(curr)->set_return_value(1);
+ }
+ //otherwise fall into the lock case
+ case ATOMIC_LOCK: {
+ if (curr->get_cv()->getClock(state->alloc_tid) <= state->alloc_clock)
+ assert_bug("Lock access before initialization");
+ state->locked = get_thread(curr);
+ ModelAction *unlock = get_last_unlock(curr);
+ //synchronize with the previous unlock statement
+ if (unlock != NULL) {
+ synchronize(unlock, curr);
+ return true;
+ }
+ break;
+ }
+ case ATOMIC_WAIT:
+ case ATOMIC_UNLOCK: {
+ /* wake up the other threads */
+ for (unsigned int i = 0; i < get_num_threads(); i++) {
+ Thread *t = get_thread(int_to_id(i));
+ Thread *curr_thrd = get_thread(curr);
+ if (t->waiting_on() == curr_thrd && t->get_pending()->is_lock())
+ scheduler->wake(t);
+ }
+
+ /* unlock the lock - after checking who was waiting on it */
+ state->locked = NULL;
+
+ if (!curr->is_wait())
+ break; /* The rest is only for ATOMIC_WAIT */
+
+ /* Should we go to sleep? (simulate spurious failures) */
+ if (curr->get_node()->get_misc() == 0) {
+ get_safe_ptr_action(&condvar_waiters_map, curr->get_location())->push_back(curr);
+ /* disable us */
+ scheduler->sleep(get_thread(curr));
+ }
+ break;
+ }
+ case ATOMIC_NOTIFY_ALL: {
+ action_list_t *waiters = get_safe_ptr_action(&condvar_waiters_map, curr->get_location());
+ //activate all the waiting threads
+ for (action_list_t::iterator rit = waiters->begin(); rit != waiters->end(); rit++) {
+ scheduler->wake(get_thread(*rit));
+ }
+ waiters->clear();
+ break;
+ }
+ case ATOMIC_NOTIFY_ONE: {
+ action_list_t *waiters = get_safe_ptr_action(&condvar_waiters_map, curr->get_location());
+ int wakeupthread = curr->get_node()->get_misc();
+ action_list_t::iterator it = waiters->begin();
+ advance(it, wakeupthread);
+ scheduler->wake(get_thread(*it));
+ waiters->erase(it);
+ break;
+ }
+
+ default:
+ ASSERT(0);
+ }
+ return false;
+}
+
+/**
+ * @brief Check if the current pending promises allow a future value to be sent
+ *
+ * It is unsafe to pass a future value back if there exists a pending promise Pr
+ * such that:
+ *
+ * reader --exec-> Pr --exec-> writer
+ *
+ * If such Pr exists, we must save the pending future value until Pr is
+ * resolved.
+ *
+ * @param writer The operation which sends the future value. Must be a write.
+ * @param reader The operation which will observe the value. Must be a read.
+ * @return True if the future value can be sent now; false if it must wait.
+ */
+bool ModelExecution::promises_may_allow(const ModelAction *writer,
+ const ModelAction *reader) const
+{
+ for (int i = promises.size() - 1; i >= 0; i--) {
+ ModelAction *pr = promises[i]->get_reader(0);
+ //reader is after promise...doesn't cross any promise
+ if (*reader > *pr)
+ return true;
+ //writer is after promise, reader before...bad...
+ if (*writer > *pr)
+ return false;
+ }
+ return true;
+}
+
+/**
+ * @brief Add a future value to a reader
+ *
+ * This function performs a few additional checks to ensure that the future
+ * value can be feasibly observed by the reader
+ *
+ * @param writer The operation whose value is sent. Must be a write.
+ * @param reader The read operation which may read the future value. Must be a read.
+ */
+void ModelExecution::add_future_value(const ModelAction *writer, ModelAction *reader)
+{
+ /* Do more ambitious checks now that mo is more complete */
+ if (!mo_may_allow(writer, reader))
+ return;
+
+ Node *node = reader->get_node();
+
+ /* Find an ancestor thread which exists at the time of the reader */
+ Thread *write_thread = get_thread(writer);
+ while (id_to_int(write_thread->get_id()) >= node->get_num_threads())
+ write_thread = write_thread->get_parent();
+
+ struct future_value fv = {
+ writer->get_write_value(),
+ writer->get_seq_number() + params->maxfuturedelay,
+ write_thread->get_id(),
+ };
+ if (node->add_future_value(fv))
+ set_latest_backtrack(reader);
+}
+
+/**
+ * Process a write ModelAction
+ * @param curr The ModelAction to process
+ * @param work The work queue, for adding fixup work
+ * @return True if the mo_graph was updated or promises were resolved
+ */
+bool ModelExecution::process_write(ModelAction *curr, work_queue_t *work)
+{
+ /* Readers to which we may send our future value */
+ ModelVector<ModelAction *> send_fv;
+
+ const ModelAction *earliest_promise_reader;
+ bool updated_promises = false;
+
+ bool updated_mod_order = w_modification_order(curr, &send_fv);
+ Promise *promise = pop_promise_to_resolve(curr);
+
+ if (promise) {
+ earliest_promise_reader = promise->get_reader(0);
+ updated_promises = resolve_promise(curr, promise, work);
+ } else
+ earliest_promise_reader = NULL;
+
+ for (unsigned int i = 0; i < send_fv.size(); i++) {
+ ModelAction *read = send_fv[i];
+
+ /* Don't send future values to reads after the Promise we resolve */
+ if (!earliest_promise_reader || *read < *earliest_promise_reader) {
+ /* Check if future value can be sent immediately */
+ if (promises_may_allow(curr, read)) {
+ add_future_value(curr, read);
+ } else {
+ futurevalues.push_back(PendingFutureValue(curr, read));
+ }
+ }
+ }
+
+ /* Check the pending future values */
+ for (int i = (int)futurevalues.size() - 1; i >= 0; i--) {
+ struct PendingFutureValue pfv = futurevalues[i];
+ if (promises_may_allow(pfv.writer, pfv.reader)) {
+ add_future_value(pfv.writer, pfv.reader);
+ futurevalues.erase(futurevalues.begin() + i);
+ }
+ }
+
+ mo_graph->commitChanges();
+ mo_check_promises(curr, false);
+
+ get_thread(curr)->set_return_value(VALUE_NONE);
+ return updated_mod_order || updated_promises;
+}
+
+/**
+ * Process a fence ModelAction
+ * @param curr The ModelAction to process
+ * @return True if synchronization was updated
+ */
+bool ModelExecution::process_fence(ModelAction *curr)
+{
+ /*
+ * fence-relaxed: no-op
+ * fence-release: only log the occurence (not in this function), for
+ * use in later synchronization
+ * fence-acquire (this function): search for hypothetical release
+ * sequences
+ * fence-seq-cst: MO constraints formed in {r,w}_modification_order
+ */
+ bool updated = false;
+ if (curr->is_acquire()) {
+ action_list_t *list = &action_trace;
+ action_list_t::reverse_iterator rit;
+ /* Find X : is_read(X) && X --sb-> curr */
+ for (rit = list->rbegin(); rit != list->rend(); rit++) {
+ ModelAction *act = *rit;
+ if (act == curr)
+ continue;
+ if (act->get_tid() != curr->get_tid())
+ continue;
+ /* Stop at the beginning of the thread */
+ if (act->is_thread_start())
+ break;
+ /* Stop once we reach a prior fence-acquire */
+ if (act->is_fence() && act->is_acquire())
+ break;
+ if (!act->is_read())
+ continue;
+ /* read-acquire will find its own release sequences */
+ if (act->is_acquire())
+ continue;
+
+ /* Establish hypothetical release sequences */
+ rel_heads_list_t release_heads;
+ get_release_seq_heads(curr, act, &release_heads);
+ for (unsigned int i = 0; i < release_heads.size(); i++)
+ synchronize(release_heads[i], curr);
+ if (release_heads.size() != 0)
+ updated = true;
+ }
+ }
+ return updated;
+}
+
+/**
+ * @brief Process the current action for thread-related activity
+ *
+ * Performs current-action processing for a THREAD_* ModelAction. Proccesses
+ * may include setting Thread status, completing THREAD_FINISH/THREAD_JOIN
+ * synchronization, etc. This function is a no-op for non-THREAD actions
+ * (e.g., ATOMIC_{READ,WRITE,RMW,LOCK}, etc.)
+ *
+ * @param curr The current action
+ * @return True if synchronization was updated or a thread completed
+ */
+bool ModelExecution::process_thread_action(ModelAction *curr)
+{
+ bool updated = false;
+
+ switch (curr->get_type()) {
+ case THREAD_CREATE: {
+ thrd_t *thrd = (thrd_t *)curr->get_location();
+ struct thread_params *params = (struct thread_params *)curr->get_value();
+ Thread *th = new Thread(get_next_id(), thrd, params->func, params->arg, get_thread(curr));
+ add_thread(th);
+ th->set_creation(curr);
+ /* Promises can be satisfied by children */
+ for (unsigned int i = 0; i < promises.size(); i++) {
+ Promise *promise = promises[i];
+ if (promise->thread_is_available(curr->get_tid()))
+ promise->add_thread(th->get_id());
+ }
+ break;
+ }
+ case THREAD_JOIN: {
+ Thread *blocking = curr->get_thread_operand();
+ ModelAction *act = get_last_action(blocking->get_id());
+ synchronize(act, curr);
+ updated = true; /* trigger rel-seq checks */
+ break;
+ }
+ case THREAD_FINISH: {
+ Thread *th = get_thread(curr);
+ /* Wake up any joining threads */
+ for (unsigned int i = 0; i < get_num_threads(); i++) {
+ Thread *waiting = get_thread(int_to_id(i));
+ if (waiting->waiting_on() == th &&
+ waiting->get_pending()->is_thread_join())
+ scheduler->wake(waiting);
+ }
+ th->complete();
+ /* Completed thread can't satisfy promises */
+ for (unsigned int i = 0; i < promises.size(); i++) {
+ Promise *promise = promises[i];
+ if (promise->thread_is_available(th->get_id()))
+ if (promise->eliminate_thread(th->get_id()))
+ priv->failed_promise = true;
+ }
+ updated = true; /* trigger rel-seq checks */
+ break;
+ }
+ case THREAD_START: {
+ check_promises(curr->get_tid(), NULL, curr->get_cv());
+ break;
+ }
+ default:
+ break;
+ }
+
+ return updated;
+}
+
+/**
+ * @brief Process the current action for release sequence fixup activity
+ *
+ * Performs model-checker release sequence fixups for the current action,
+ * forcing a single pending release sequence to break (with a given, potential
+ * "loose" write) or to complete (i.e., synchronize). If a pending release
+ * sequence forms a complete release sequence, then we must perform the fixup
+ * synchronization, mo_graph additions, etc.
+ *
+ * @param curr The current action; must be a release sequence fixup action
+ * @param work_queue The work queue to which to add work items as they are
+ * generated
+ */
+void ModelExecution::process_relseq_fixup(ModelAction *curr, work_queue_t *work_queue)
+{
+ const ModelAction *write = curr->get_node()->get_relseq_break();
+ struct release_seq *sequence = pending_rel_seqs.back();
+ pending_rel_seqs.pop_back();
+ ASSERT(sequence);
+ ModelAction *acquire = sequence->acquire;
+ const ModelAction *rf = sequence->rf;
+ const ModelAction *release = sequence->release;
+ ASSERT(acquire);
+ ASSERT(release);
+ ASSERT(rf);
+ ASSERT(release->same_thread(rf));
+
+ if (write == NULL) {
+ /**
+ * @todo Forcing a synchronization requires that we set
+ * modification order constraints. For instance, we can't allow
+ * a fixup sequence in which two separate read-acquire
+ * operations read from the same sequence, where the first one
+ * synchronizes and the other doesn't. Essentially, we can't
+ * allow any writes to insert themselves between 'release' and
+ * 'rf'
+ */
+
+ /* Must synchronize */
+ if (!synchronize(release, acquire))
+ return;
+
+ /* Propagate the changed clock vector */
+ propagate_clockvector(acquire, work_queue);
+ } else {
+ /* Break release sequence with new edges:
+ * release --mo--> write --mo--> rf */
+ mo_graph->addEdge(release, write);
+ mo_graph->addEdge(write, rf);
+ }
+
+ /* See if we have realized a data race */
+ checkDataRaces();
+}
+
+/**
+ * Initialize the current action by performing one or more of the following
+ * actions, as appropriate: merging RMWR and RMWC/RMW actions, stepping forward
+ * in the NodeStack, manipulating backtracking sets, allocating and
+ * initializing clock vectors, and computing the promises to fulfill.
+ *
+ * @param curr The current action, as passed from the user context; may be
+ * freed/invalidated after the execution of this function, with a different
+ * action "returned" its place (pass-by-reference)
+ * @return True if curr is a newly-explored action; false otherwise
+ */
+bool ModelExecution::initialize_curr_action(ModelAction **curr)
+{
+ ModelAction *newcurr;
+
+ if ((*curr)->is_rmwc() || (*curr)->is_rmw()) {
+ newcurr = process_rmw(*curr);
+ delete *curr;
+
+ if (newcurr->is_rmw())
+ compute_promises(newcurr);
+
+ *curr = newcurr;
+ return false;
+ }
+
+ (*curr)->set_seq_number(get_next_seq_num());
+
+ newcurr = node_stack->explore_action(*curr, scheduler->get_enabled_array());
+ if (newcurr) {
+ /* First restore type and order in case of RMW operation */
+ if ((*curr)->is_rmwr())
+ newcurr->copy_typeandorder(*curr);
+
+ ASSERT((*curr)->get_location() == newcurr->get_location());
+ newcurr->copy_from_new(*curr);
+
+ /* Discard duplicate ModelAction; use action from NodeStack */
+ delete *curr;
+
+ /* Always compute new clock vector */
+ newcurr->create_cv(get_parent_action(newcurr->get_tid()));
+
+ *curr = newcurr;
+ return false; /* Action was explored previously */
+ } else {
+ newcurr = *curr;
+
+ /* Always compute new clock vector */
+ newcurr->create_cv(get_parent_action(newcurr->get_tid()));
+
+ /* Assign most recent release fence */
+ newcurr->set_last_fence_release(get_last_fence_release(newcurr->get_tid()));
+
+ /*
+ * Perform one-time actions when pushing new ModelAction onto
+ * NodeStack
+ */
+ if (newcurr->is_write())
+ compute_promises(newcurr);
+ else if (newcurr->is_relseq_fixup())
+ compute_relseq_breakwrites(newcurr);
+ else if (newcurr->is_wait())
+ newcurr->get_node()->set_misc_max(2);
+ else if (newcurr->is_notify_one()) {
+ newcurr->get_node()->set_misc_max(get_safe_ptr_action(&condvar_waiters_map, newcurr->get_location())->size());
+ }
+ return true; /* This was a new ModelAction */
+ }
+}
+
+/**
+ * @brief Establish reads-from relation between two actions
+ *
+ * Perform basic operations involved with establishing a concrete rf relation,
+ * including setting the ModelAction data and checking for release sequences.
+ *
+ * @param act The action that is reading (must be a read)
+ * @param rf The action from which we are reading (must be a write)
+ *
+ * @return True if this read established synchronization
+ */
+bool ModelExecution::read_from(ModelAction *act, const ModelAction *rf)
+{
+ ASSERT(rf);
+ ASSERT(rf->is_write());
+
+ act->set_read_from(rf);
+ if (act->is_acquire()) {
+ rel_heads_list_t release_heads;
+ get_release_seq_heads(act, act, &release_heads);
+ int num_heads = release_heads.size();
+ for (unsigned int i = 0; i < release_heads.size(); i++)
+ if (!synchronize(release_heads[i], act))
+ num_heads--;
+ return num_heads > 0;
+ }
+ return false;
+}
+
+/**
+ * @brief Synchronizes two actions
+ *
+ * When A synchronizes with B (or A --sw-> B), B inherits A's clock vector.
+ * This function performs the synchronization as well as providing other hooks
+ * for other checks along with synchronization.
+ *
+ * @param first The left-hand side of the synchronizes-with relation
+ * @param second The right-hand side of the synchronizes-with relation
+ * @return True if the synchronization was successful (i.e., was consistent
+ * with the execution order); false otherwise
+ */
+bool ModelExecution::synchronize(const ModelAction *first, ModelAction *second)
+{
+ if (*second < *first) {
+ set_bad_synchronization();
+ return false;
+ }
+ check_promises(first->get_tid(), second->get_cv(), first->get_cv());
+ return second->synchronize_with(first);
+}
+
+/**
+ * Check promises and eliminate potentially-satisfying threads when a thread is
+ * blocked (e.g., join, lock). A thread which is waiting on another thread can
+ * no longer satisfy a promise generated from that thread.
+ *
+ * @param blocker The thread on which a thread is waiting
+ * @param waiting The waiting thread
+ */
+void ModelExecution::thread_blocking_check_promises(Thread *blocker, Thread *waiting)
+{
+ for (unsigned int i = 0; i < promises.size(); i++) {
+ Promise *promise = promises[i];
+ if (!promise->thread_is_available(waiting->get_id()))
+ continue;
+ for (unsigned int j = 0; j < promise->get_num_readers(); j++) {
+ ModelAction *reader = promise->get_reader(j);
+ if (reader->get_tid() != blocker->get_id())
+ continue;
+ if (promise->eliminate_thread(waiting->get_id())) {
+ /* Promise has failed */
+ priv->failed_promise = true;
+ } else {
+ /* Only eliminate the 'waiting' thread once */
+ return;
+ }
+ }
+ }
+}
+
+/**
+ * @brief Check whether a model action is enabled.
+ *
+ * Checks whether an operation would be successful (i.e., is a lock already
+ * locked, or is the joined thread already complete).
+ *
+ * For yield-blocking, yields are never enabled.
+ *
+ * @param curr is the ModelAction to check whether it is enabled.
+ * @return a bool that indicates whether the action is enabled.
+ */
+bool ModelExecution::check_action_enabled(ModelAction *curr) {
+ if (curr->is_lock()) {
+ std::mutex *lock = curr->get_mutex();
+ struct std::mutex_state *state = lock->get_state();
+ if (state->locked)
+ return false;
+ } else if (curr->is_thread_join()) {
+ Thread *blocking = curr->get_thread_operand();
+ if (!blocking->is_complete()) {
+ thread_blocking_check_promises(blocking, get_thread(curr));
+ return false;
+ }
+ } else if (params->yieldblock && curr->is_yield()) {
+ return false;
+ }
+
+ return true;
+}
+
+/**
+ * This is the heart of the model checker routine. It performs model-checking
+ * actions corresponding to a given "current action." Among other processes, it
+ * calculates reads-from relationships, updates synchronization clock vectors,
+ * forms a memory_order constraints graph, and handles replay/backtrack
+ * execution when running permutations of previously-observed executions.
+ *
+ * @param curr The current action to process
+ * @return The ModelAction that is actually executed; may be different than
+ * curr
+ */
+ModelAction * ModelExecution::check_current_action(ModelAction *curr)
+{
+ ASSERT(curr);
+ bool second_part_of_rmw = curr->is_rmwc() || curr->is_rmw();
+ bool newly_explored = initialize_curr_action(&curr);
+
+ DBG();
+
+ wake_up_sleeping_actions(curr);
+
+ /* Compute fairness information for CHESS yield algorithm */
+ if (params->yieldon) {
+ curr->get_node()->update_yield(scheduler);
+ }
+
+ /* Add the action to lists before any other model-checking tasks */
+ if (!second_part_of_rmw)
+ add_action_to_lists(curr);
+
+ /* Build may_read_from set for newly-created actions */
+ if (newly_explored && curr->is_read())
+ build_may_read_from(curr);
+
+ /* Initialize work_queue with the "current action" work */
+ work_queue_t work_queue(1, CheckCurrWorkEntry(curr));
+ while (!work_queue.empty() && !has_asserted()) {
+ WorkQueueEntry work = work_queue.front();
+ work_queue.pop_front();
+
+ switch (work.type) {
+ case WORK_CHECK_CURR_ACTION: {
+ ModelAction *act = work.action;
+ bool update = false; /* update this location's release seq's */
+ bool update_all = false; /* update all release seq's */
+
+ if (process_thread_action(curr))
+ update_all = true;
+
+ if (act->is_read() && !second_part_of_rmw && process_read(act))
+ update = true;
+
+ if (act->is_write() && process_write(act, &work_queue))
+ update = true;
+
+ if (act->is_fence() && process_fence(act))
+ update_all = true;
+
+ if (act->is_mutex_op() && process_mutex(act))
+ update_all = true;
+
+ if (act->is_relseq_fixup())
+ process_relseq_fixup(curr, &work_queue);
+
+ if (update_all)
+ work_queue.push_back(CheckRelSeqWorkEntry(NULL));
+ else if (update)
+ work_queue.push_back(CheckRelSeqWorkEntry(act->get_location()));
+ break;
+ }
+ case WORK_CHECK_RELEASE_SEQ:
+ resolve_release_sequences(work.location, &work_queue);
+ break;
+ case WORK_CHECK_MO_EDGES: {
+ /** @todo Complete verification of work_queue */
+ ModelAction *act = work.action;
+ bool updated = false;
+
+ if (act->is_read()) {
+ const ModelAction *rf = act->get_reads_from();
+ const Promise *promise = act->get_reads_from_promise();
+ if (rf) {
+ if (r_modification_order(act, rf))
+ updated = true;
+ } else if (promise) {
+ if (r_modification_order(act, promise))
+ updated = true;
+ }
+ }
+ if (act->is_write()) {
+ if (w_modification_order(act, NULL))
+ updated = true;
+ }
+ mo_graph->commitChanges();
+
+ if (updated)
+ work_queue.push_back(CheckRelSeqWorkEntry(act->get_location()));
+ break;
+ }
+ default:
+ ASSERT(false);
+ break;
+ }
+ }
+
+ check_curr_backtracking(curr);
+ set_backtracking(curr);
+ return curr;
+}
+
+void ModelExecution::check_curr_backtracking(ModelAction *curr)
+{
+ Node *currnode = curr->get_node();
+ Node *parnode = currnode->get_parent();
+
+ if ((parnode && !parnode->backtrack_empty()) ||
+ !currnode->misc_empty() ||
+ !currnode->read_from_empty() ||
+ !currnode->promise_empty() ||
+ !currnode->relseq_break_empty()) {
+ set_latest_backtrack(curr);
+ }
+}
+
+bool ModelExecution::promises_expired() const
+{
+ for (unsigned int i = 0; i < promises.size(); i++) {
+ Promise *promise = promises[i];
+ if (promise->get_expiration() < priv->used_sequence_numbers)
+ return true;
+ }
+ return false;
+}
+
+/**
+ * This is the strongest feasibility check available.
+ * @return whether the current trace (partial or complete) must be a prefix of
+ * a feasible trace.
+ */
+bool ModelExecution::isfeasibleprefix() const
+{
+ return pending_rel_seqs.size() == 0 && is_feasible_prefix_ignore_relseq();
+}
+
+/**
+ * Print disagnostic information about an infeasible execution
+ * @param prefix A string to prefix the output with; if NULL, then a default
+ * message prefix will be provided
+ */
+void ModelExecution::print_infeasibility(const char *prefix) const
+{
+ char buf[100];
+ char *ptr = buf;
+ if (mo_graph->checkForCycles())
+ ptr += sprintf(ptr, "[mo cycle]");
+ if (priv->failed_promise)
+ ptr += sprintf(ptr, "[failed promise]");
+ if (priv->too_many_reads)
+ ptr += sprintf(ptr, "[too many reads]");
+ if (priv->no_valid_reads)
+ ptr += sprintf(ptr, "[no valid reads-from]");
+ if (priv->bad_synchronization)
+ ptr += sprintf(ptr, "[bad sw ordering]");
+ if (promises_expired())
+ ptr += sprintf(ptr, "[promise expired]");
+ if (promises.size() != 0)
+ ptr += sprintf(ptr, "[unresolved promise]");
+ if (ptr != buf)
+ model_print("%s: %s", prefix ? prefix : "Infeasible", buf);
+}
+
+/**
+ * Returns whether the current completed trace is feasible, except for pending
+ * release sequences.
+ */
+bool ModelExecution::is_feasible_prefix_ignore_relseq() const
+{
+ return !is_infeasible() && promises.size() == 0;
+}
+
+/**
+ * Check if the current partial trace is infeasible. Does not check any
+ * end-of-execution flags, which might rule out the execution. Thus, this is
+ * useful only for ruling an execution as infeasible.
+ * @return whether the current partial trace is infeasible.
+ */
+bool ModelExecution::is_infeasible() const
+{
+ return mo_graph->checkForCycles() ||
+ priv->no_valid_reads ||
+ priv->failed_promise ||
+ priv->too_many_reads ||
+ priv->bad_synchronization ||
+ promises_expired();
+}
+
+/** Close out a RMWR by converting previous RMWR into a RMW or READ. */
+ModelAction * ModelExecution::process_rmw(ModelAction *act) {
+ ModelAction *lastread = get_last_action(act->get_tid());
+ lastread->process_rmw(act);
+ if (act->is_rmw()) {
+ if (lastread->get_reads_from())
+ mo_graph->addRMWEdge(lastread->get_reads_from(), lastread);
+ else
+ mo_graph->addRMWEdge(lastread->get_reads_from_promise(), lastread);
+ mo_graph->commitChanges();
+ }
+ return lastread;
+}
+
+/**
+ * A helper function for ModelExecution::check_recency, to check if the current
+ * thread is able to read from a different write/promise for 'params.maxreads'
+ * number of steps and if that write/promise should become visible (i.e., is
+ * ordered later in the modification order). This helps model memory liveness.
+ *
+ * @param curr The current action. Must be a read.
+ * @param rf The write/promise from which we plan to read
+ * @param other_rf The write/promise from which we may read
+ * @return True if we were able to read from other_rf for params.maxreads steps
+ */
+template <typename T, typename U>
+bool ModelExecution::should_read_instead(const ModelAction *curr, const T *rf, const U *other_rf) const
+{
+ /* Need a different write/promise */
+ if (other_rf->equals(rf))
+ return false;
+
+ /* Only look for "newer" writes/promises */
+ if (!mo_graph->checkReachable(rf, other_rf))
+ return false;
+
+ SnapVector<action_list_t> *thrd_lists = obj_thrd_map.get(curr->get_location());
+ action_list_t *list = &(*thrd_lists)[id_to_int(curr->get_tid())];
+ action_list_t::reverse_iterator rit = list->rbegin();
+ ASSERT((*rit) == curr);
+ /* Skip past curr */
+ rit++;
+
+ /* Does this write/promise work for everyone? */
+ for (int i = 0; i < params->maxreads; i++, rit++) {
+ ModelAction *act = *rit;
+ if (!act->may_read_from(other_rf))
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Checks whether a thread has read from the same write or Promise for too many
+ * times without seeing the effects of a later write/Promise.
+ *
+ * Basic idea:
+ * 1) there must a different write/promise that we could read from,
+ * 2) we must have read from the same write/promise in excess of maxreads times,
+ * 3) that other write/promise must have been in the reads_from set for maxreads times, and
+ * 4) that other write/promise must be mod-ordered after the write/promise we are reading.
+ *
+ * If so, we decide that the execution is no longer feasible.
+ *
+ * @param curr The current action. Must be a read.
+ * @param rf The ModelAction/Promise from which we might read.
+ * @return True if the read should succeed; false otherwise
+ */
+template <typename T>
+bool ModelExecution::check_recency(ModelAction *curr, const T *rf) const
+{
+ if (!params->maxreads)
+ return true;
+
+ //NOTE: Next check is just optimization, not really necessary....
+ if (curr->get_node()->get_read_from_past_size() +
+ curr->get_node()->get_read_from_promise_size() <= 1)
+ return true;
+
+ SnapVector<action_list_t> *thrd_lists = obj_thrd_map.get(curr->get_location());
+ int tid = id_to_int(curr->get_tid());
+ ASSERT(tid < (int)thrd_lists->size());
+ action_list_t *list = &(*thrd_lists)[tid];
+ action_list_t::reverse_iterator rit = list->rbegin();
+ ASSERT((*rit) == curr);
+ /* Skip past curr */
+ rit++;
+
+ action_list_t::reverse_iterator ritcopy = rit;
+ /* See if we have enough reads from the same value */
+ for (int count = 0; count < params->maxreads; ritcopy++, count++) {
+ if (ritcopy == list->rend())
+ return true;
+ ModelAction *act = *ritcopy;
+ if (!act->is_read())
+ return true;
+ if (act->get_reads_from_promise() && !act->get_reads_from_promise()->equals(rf))
+ return true;
+ if (act->get_reads_from() && !act->get_reads_from()->equals(rf))
+ return true;
+ if (act->get_node()->get_read_from_past_size() +
+ act->get_node()->get_read_from_promise_size() <= 1)
+ return true;
+ }
+ for (int i = 0; i < curr->get_node()->get_read_from_past_size(); i++) {
+ const ModelAction *write = curr->get_node()->get_read_from_past(i);
+ if (should_read_instead(curr, rf, write))
+ return false; /* liveness failure */
+ }
+ for (int i = 0; i < curr->get_node()->get_read_from_promise_size(); i++) {
+ const Promise *promise = curr->get_node()->get_read_from_promise(i);
+ if (should_read_instead(curr, rf, promise))
+ return false; /* liveness failure */
+ }
+ return true;
+}
+
+/**
+ * @brief Updates the mo_graph with the constraints imposed from the current
+ * read.
+ *
+ * Basic idea is the following: Go through each other thread and find
+ * the last action that happened before our read. Two cases:
+ *
+ * -# The action is a write: that write must either occur before
+ * the write we read from or be the write we read from.
+ * -# The action is a read: the write that that action read from
+ * must occur before the write we read from or be the same write.
+ *
+ * @param curr The current action. Must be a read.
+ * @param rf The ModelAction or Promise that curr reads from. Must be a write.
+ * @return True if modification order edges were added; false otherwise
+ */
+template <typename rf_type>
+bool ModelExecution::r_modification_order(ModelAction *curr, const rf_type *rf)
+{
+ SnapVector<action_list_t> *thrd_lists = obj_thrd_map.get(curr->get_location());
+ unsigned int i;
+ bool added = false;
+ ASSERT(curr->is_read());
+
+ /* Last SC fence in the current thread */
+ ModelAction *last_sc_fence_local = get_last_seq_cst_fence(curr->get_tid(), NULL);
+ ModelAction *last_sc_write = NULL;
+ if (curr->is_seqcst())
+ last_sc_write = get_last_seq_cst_write(curr);
+
+ /* Iterate over all threads */
+ for (i = 0; i < thrd_lists->size(); i++) {
+ /* Last SC fence in thread i */
+ ModelAction *last_sc_fence_thread_local = NULL;
+ if (int_to_id((int)i) != curr->get_tid())
+ last_sc_fence_thread_local = get_last_seq_cst_fence(int_to_id(i), NULL);
+
+ /* Last SC fence in thread i, before last SC fence in current thread */
+ ModelAction *last_sc_fence_thread_before = NULL;
+ if (last_sc_fence_local)
+ last_sc_fence_thread_before = get_last_seq_cst_fence(int_to_id(i), last_sc_fence_local);
+
+ /* Iterate over actions in thread, starting from most recent */
+ action_list_t *list = &(*thrd_lists)[i];
+ action_list_t::reverse_iterator rit;
+ for (rit = list->rbegin(); rit != list->rend(); rit++) {
+ ModelAction *act = *rit;
+
+ /* Skip curr */
+ if (act == curr)
+ continue;
+ /* Don't want to add reflexive edges on 'rf' */
+ if (act->equals(rf)) {
+ if (act->happens_before(curr))
+ break;
+ else
+ continue;
+ }
+
+ if (act->is_write()) {
+ /* C++, Section 29.3 statement 5 */
+ if (curr->is_seqcst() && last_sc_fence_thread_local &&
+ *act < *last_sc_fence_thread_local) {
+ added = mo_graph->addEdge(act, rf) || added;
+ break;
+ }
+ /* C++, Section 29.3 statement 4 */
+ else if (act->is_seqcst() && last_sc_fence_local &&
+ *act < *last_sc_fence_local) {
+ added = mo_graph->addEdge(act, rf) || added;
+ break;
+ }
+ /* C++, Section 29.3 statement 6 */
+ else if (last_sc_fence_thread_before &&
+ *act < *last_sc_fence_thread_before) {
+ added = mo_graph->addEdge(act, rf) || added;
+ break;
+ }
+ }
+
+ /* C++, Section 29.3 statement 3 (second subpoint) */
+ if (curr->is_seqcst() && last_sc_write && act == last_sc_write) {
+ added = mo_graph->addEdge(act, rf) || added;
+ break;
+ }
+
+ /*
+ * Include at most one act per-thread that "happens
+ * before" curr
+ */
+ if (act->happens_before(curr)) {
+ if (act->is_write()) {
+ added = mo_graph->addEdge(act, rf) || added;
+ } else {
+ const ModelAction *prevrf = act->get_reads_from();
+ const Promise *prevrf_promise = act->get_reads_from_promise();
+ if (prevrf) {
+ if (!prevrf->equals(rf))
+ added = mo_graph->addEdge(prevrf, rf) || added;
+ } else if (!prevrf_promise->equals(rf)) {
+ added = mo_graph->addEdge(prevrf_promise, rf) || added;
+ }
+ }
+ break;
+ }
+ }
+ }
+
+ /*
+ * All compatible, thread-exclusive promises must be ordered after any
+ * concrete loads from the same thread
+ */
+ for (unsigned int i = 0; i < promises.size(); i++)
+ if (promises[i]->is_compatible_exclusive(curr))
+ added = mo_graph->addEdge(rf, promises[i]) || added;
+
+ return added;
+}
+
+/**
+ * Updates the mo_graph with the constraints imposed from the current write.
+ *
+ * Basic idea is the following: Go through each other thread and find
+ * the lastest action that happened before our write. Two cases:
+ *
+ * (1) The action is a write => that write must occur before
+ * the current write
+ *
+ * (2) The action is a read => the write that that action read from
+ * must occur before the current write.
+ *
+ * This method also handles two other issues:
+ *
+ * (I) Sequential Consistency: Making sure that if the current write is
+ * seq_cst, that it occurs after the previous seq_cst write.
+ *
+ * (II) Sending the write back to non-synchronizing reads.
+ *
+ * @param curr The current action. Must be a write.
+ * @param send_fv A vector for stashing reads to which we may pass our future
+ * value. If NULL, then don't record any future values.
+ * @return True if modification order edges were added; false otherwise
+ */
+bool ModelExecution::w_modification_order(ModelAction *curr, ModelVector<ModelAction *> *send_fv)
+{
+ SnapVector<action_list_t> *thrd_lists = obj_thrd_map.get(curr->get_location());
+ unsigned int i;
+ bool added = false;
+ ASSERT(curr->is_write());
+
+ if (curr->is_seqcst()) {
+ /* We have to at least see the last sequentially consistent write,
+ so we are initialized. */
+ ModelAction *last_seq_cst = get_last_seq_cst_write(curr);
+ if (last_seq_cst != NULL) {
+ added = mo_graph->addEdge(last_seq_cst, curr) || added;
+ }
+ }
+
+ /* Last SC fence in the current thread */
+ ModelAction *last_sc_fence_local = get_last_seq_cst_fence(curr->get_tid(), NULL);
+
+ /* Iterate over all threads */
+ for (i = 0; i < thrd_lists->size(); i++) {
+ /* Last SC fence in thread i, before last SC fence in current thread */
+ ModelAction *last_sc_fence_thread_before = NULL;
+ if (last_sc_fence_local && int_to_id((int)i) != curr->get_tid())
+ last_sc_fence_thread_before = get_last_seq_cst_fence(int_to_id(i), last_sc_fence_local);
+
+ /* Iterate over actions in thread, starting from most recent */
+ action_list_t *list = &(*thrd_lists)[i];
+ action_list_t::reverse_iterator rit;
+ for (rit = list->rbegin(); rit != list->rend(); rit++) {
+ ModelAction *act = *rit;
+ if (act == curr) {
+ /*
+ * 1) If RMW and it actually read from something, then we
+ * already have all relevant edges, so just skip to next
+ * thread.
+ *
+ * 2) If RMW and it didn't read from anything, we should
+ * whatever edge we can get to speed up convergence.
+ *
+ * 3) If normal write, we need to look at earlier actions, so
+ * continue processing list.
+ */
+ if (curr->is_rmw()) {
+ if (curr->get_reads_from() != NULL)
+ break;
+ else
+ continue;
+ } else
+ continue;
+ }
+
+ /* C++, Section 29.3 statement 7 */
+ if (last_sc_fence_thread_before && act->is_write() &&
+ *act < *last_sc_fence_thread_before) {
+ added = mo_graph->addEdge(act, curr) || added;
+ break;
+ }
+
+ /*
+ * Include at most one act per-thread that "happens
+ * before" curr
+ */
+ if (act->happens_before(curr)) {
+ /*
+ * Note: if act is RMW, just add edge:
+ * act --mo--> curr
+ * The following edge should be handled elsewhere:
+ * readfrom(act) --mo--> act
+ */
+ if (act->is_write())
+ added = mo_graph->addEdge(act, curr) || added;
+ else if (act->is_read()) {
+ //if previous read accessed a null, just keep going
+ if (act->get_reads_from() == NULL)
+ continue;
+ added = mo_graph->addEdge(act->get_reads_from(), curr) || added;
+ }
+ break;
+ } else if (act->is_read() && !act->could_synchronize_with(curr) &&
+ !act->same_thread(curr)) {
+ /* We have an action that:
+ (1) did not happen before us
+ (2) is a read and we are a write
+ (3) cannot synchronize with us
+ (4) is in a different thread
+ =>
+ that read could potentially read from our write. Note that
+ these checks are overly conservative at this point, we'll
+ do more checks before actually removing the
+ pendingfuturevalue.
+
+ */
+ if (send_fv && thin_air_constraint_may_allow(curr, act)) {
+ if (!is_infeasible())
+ send_fv->push_back(act);
+ else if (curr->is_rmw() && act->is_rmw() && curr->get_reads_from() && curr->get_reads_from() == act->get_reads_from())
+ add_future_value(curr, act);
+ }
+ }
+ }
+ }
+
+ /*
+ * All compatible, thread-exclusive promises must be ordered after any
+ * concrete stores to the same thread, or else they can be merged with
+ * this store later
+ */
+ for (unsigned int i = 0; i < promises.size(); i++)
+ if (promises[i]->is_compatible_exclusive(curr))
+ added = mo_graph->addEdge(curr, promises[i]) || added;
+
+ return added;
+}
+
+/** Arbitrary reads from the future are not allowed. Section 29.3
+ * part 9 places some constraints. This method checks one result of constraint
+ * constraint. Others require compiler support. */
+bool ModelExecution::thin_air_constraint_may_allow(const ModelAction *writer, const ModelAction *reader) const
+{
+ if (!writer->is_rmw())
+ return true;
+
+ if (!reader->is_rmw())
+ return true;
+
+ for (const ModelAction *search = writer->get_reads_from(); search != NULL; search = search->get_reads_from()) {
+ if (search == reader)
+ return false;
+ if (search->get_tid() == reader->get_tid() &&
+ search->happens_before(reader))
+ break;
+ }
+
+ return true;
+}
+
+/**
+ * Arbitrary reads from the future are not allowed. Section 29.3 part 9 places
+ * some constraints. This method checks one the following constraint (others
+ * require compiler support):
+ *
+ * If X --hb-> Y --mo-> Z, then X should not read from Z.
+ * If X --hb-> Y, A --rf-> Y, and A --mo-> Z, then X should not read from Z.
+ */
+bool ModelExecution::mo_may_allow(const ModelAction *writer, const ModelAction *reader)
+{
+ SnapVector<action_list_t> *thrd_lists = obj_thrd_map.get(reader->get_location());
+ unsigned int i;
+ /* Iterate over all threads */
+ for (i = 0; i < thrd_lists->size(); i++) {
+ const ModelAction *write_after_read = NULL;
+
+ /* Iterate over actions in thread, starting from most recent */
+ action_list_t *list = &(*thrd_lists)[i];
+ action_list_t::reverse_iterator rit;
+ for (rit = list->rbegin(); rit != list->rend(); rit++) {
+ ModelAction *act = *rit;
+
+ /* Don't disallow due to act == reader */
+ if (!reader->happens_before(act) || reader == act)
+ break;
+ else if (act->is_write())
+ write_after_read = act;
+ else if (act->is_read() && act->get_reads_from() != NULL)
+ write_after_read = act->get_reads_from();
+ }
+
+ if (write_after_read && write_after_read != writer && mo_graph->checkReachable(write_after_read, writer))
+ return false;
+ }
+ return true;
+}
+
+/**
+ * Finds the head(s) of the release sequence(s) containing a given ModelAction.
+ * The ModelAction under consideration is expected to be taking part in
+ * release/acquire synchronization as an object of the "reads from" relation.
+ * Note that this can only provide release sequence support for RMW chains
+ * which do not read from the future, as those actions cannot be traced until
+ * their "promise" is fulfilled. Similarly, we may not even establish the
+ * presence of a release sequence with certainty, as some modification order
+ * constraints may be decided further in the future. Thus, this function
+ * "returns" two pieces of data: a pass-by-reference vector of @a release_heads
+ * and a boolean representing certainty.
+ *
+ * @param rf The action that might be part of a release sequence. Must be a
+ * write.
+ * @param release_heads A pass-by-reference style return parameter. After
+ * execution of this function, release_heads will contain the heads of all the
+ * relevant release sequences, if any exists with certainty
+ * @param pending A pass-by-reference style return parameter which is only used
+ * when returning false (i.e., uncertain). Returns most information regarding
+ * an uncertain release sequence, including any write operations that might
+ * break the sequence.
+ * @return true, if the ModelExecution is certain that release_heads is complete;
+ * false otherwise
+ */
+bool ModelExecution::release_seq_heads(const ModelAction *rf,
+ rel_heads_list_t *release_heads,
+ struct release_seq *pending) const
+{
+ /* Only check for release sequences if there are no cycles */
+ if (mo_graph->checkForCycles())
+ return false;
+
+ for ( ; rf != NULL; rf = rf->get_reads_from()) {
+ ASSERT(rf->is_write());
+
+ if (rf->is_release())
+ release_heads->push_back(rf);
+ else if (rf->get_last_fence_release())
+ release_heads->push_back(rf->get_last_fence_release());
+ if (!rf->is_rmw())
+ break; /* End of RMW chain */
+
+ /** @todo Need to be smarter here... In the linux lock
+ * example, this will run to the beginning of the program for
+ * every acquire. */
+ /** @todo The way to be smarter here is to keep going until 1
+ * thread has a release preceded by an acquire and you've seen
+ * both. */
+
+ /* acq_rel RMW is a sufficient stopping condition */
+ if (rf->is_acquire() && rf->is_release())
+ return true; /* complete */
+ };
+ if (!rf) {
+ /* read from future: need to settle this later */
+ pending->rf = NULL;
+ return false; /* incomplete */
+ }
+
+ if (rf->is_release())
+ return true; /* complete */
+
+ /* else relaxed write
+ * - check for fence-release in the same thread (29.8, stmt. 3)
+ * - check modification order for contiguous subsequence
+ * -> rf must be same thread as release */
+
+ const ModelAction *fence_release = rf->get_last_fence_release();
+ /* Synchronize with a fence-release unconditionally; we don't need to
+ * find any more "contiguous subsequence..." for it */
+ if (fence_release)
+ release_heads->push_back(fence_release);
+
+ int tid = id_to_int(rf->get_tid());
+ SnapVector<action_list_t> *thrd_lists = obj_thrd_map.get(rf->get_location());
+ action_list_t *list = &(*thrd_lists)[tid];
+ action_list_t::const_reverse_iterator rit;
+
+ /* Find rf in the thread list */
+ rit = std::find(list->rbegin(), list->rend(), rf);
+ ASSERT(rit != list->rend());
+
+ /* Find the last {write,fence}-release */
+ for (; rit != list->rend(); rit++) {
+ if (fence_release && *(*rit) < *fence_release)
+ break;
+ if ((*rit)->is_release())
+ break;
+ }
+ if (rit == list->rend()) {
+ /* No write-release in this thread */
+ return true; /* complete */
+ } else if (fence_release && *(*rit) < *fence_release) {
+ /* The fence-release is more recent (and so, "stronger") than
+ * the most recent write-release */
+ return true; /* complete */
+ } /* else, need to establish contiguous release sequence */
+ ModelAction *release = *rit;
+
+ ASSERT(rf->same_thread(release));
+
+ pending->writes.clear();
+
+ bool certain = true;
+ for (unsigned int i = 0; i < thrd_lists->size(); i++) {
+ if (id_to_int(rf->get_tid()) == (int)i)
+ continue;
+ list = &(*thrd_lists)[i];
+
+ /* Can we ensure no future writes from this thread may break
+ * the release seq? */
+ bool future_ordered = false;
+
+ ModelAction *last = get_last_action(int_to_id(i));
+ Thread *th = get_thread(int_to_id(i));
+ if ((last && rf->happens_before(last)) ||
+ !is_enabled(th) ||
+ th->is_complete())
+ future_ordered = true;
+
+ ASSERT(!th->is_model_thread() || future_ordered);
+
+ for (rit = list->rbegin(); rit != list->rend(); rit++) {
+ const ModelAction *act = *rit;
+ /* Reach synchronization -> this thread is complete */
+ if (act->happens_before(release))
+ break;
+ if (rf->happens_before(act)) {
+ future_ordered = true;
+ continue;
+ }
+
+ /* Only non-RMW writes can break release sequences */
+ if (!act->is_write() || act->is_rmw())
+ continue;
+
+ /* Check modification order */
+ if (mo_graph->checkReachable(rf, act)) {
+ /* rf --mo--> act */
+ future_ordered = true;
+ continue;
+ }
+ if (mo_graph->checkReachable(act, release))
+ /* act --mo--> release */
+ break;
+ if (mo_graph->checkReachable(release, act) &&
+ mo_graph->checkReachable(act, rf)) {
+ /* release --mo-> act --mo--> rf */
+ return true; /* complete */
+ }
+ /* act may break release sequence */
+ pending->writes.push_back(act);
+ certain = false;
+ }
+ if (!future_ordered)
+ certain = false; /* This thread is uncertain */
+ }
+
+ if (certain) {
+ release_heads->push_back(release);
+ pending->writes.clear();
+ } else {
+ pending->release = release;
+ pending->rf = rf;
+ }
+ return certain;
+}
+
+/**
+ * An interface for getting the release sequence head(s) with which a
+ * given ModelAction must synchronize. This function only returns a non-empty
+ * result when it can locate a release sequence head with certainty. Otherwise,
+ * it may mark the internal state of the ModelExecution so that it will handle
+ * the release sequence at a later time, causing @a acquire to update its
+ * synchronization at some later point in execution.
+ *
+ * @param acquire The 'acquire' action that may synchronize with a release
+ * sequence
+ * @param read The read action that may read from a release sequence; this may
+ * be the same as acquire, or else an earlier action in the same thread (i.e.,
+ * when 'acquire' is a fence-acquire)
+ * @param release_heads A pass-by-reference return parameter. Will be filled
+ * with the head(s) of the release sequence(s), if they exists with certainty.
+ * @see ModelExecution::release_seq_heads
+ */
+void ModelExecution::get_release_seq_heads(ModelAction *acquire,
+ ModelAction *read, rel_heads_list_t *release_heads)
+{
+ const ModelAction *rf = read->get_reads_from();
+ struct release_seq *sequence = (struct release_seq *)snapshot_calloc(1, sizeof(struct release_seq));
+ sequence->acquire = acquire;
+ sequence->read = read;
+
+ if (!release_seq_heads(rf, release_heads, sequence)) {
+ /* add act to 'lazy checking' list */
+ pending_rel_seqs.push_back(sequence);
+ } else {
+ snapshot_free(sequence);
+ }
+}
+
+/**
+ * @brief Propagate a modified clock vector to actions later in the execution
+ * order
+ *
+ * After an acquire operation lazily completes a release-sequence
+ * synchronization, we must update all clock vectors for operations later than
+ * the acquire in the execution order.
+ *
+ * @param acquire The ModelAction whose clock vector must be propagated
+ * @param work The work queue to which we can add work items, if this
+ * propagation triggers more updates (e.g., to the modification order)
+ */
+void ModelExecution::propagate_clockvector(ModelAction *acquire, work_queue_t *work)
+{
+ /* Re-check all pending release sequences */
+ work->push_back(CheckRelSeqWorkEntry(NULL));
+ /* Re-check read-acquire for mo_graph edges */
+ work->push_back(MOEdgeWorkEntry(acquire));
+
+ /* propagate synchronization to later actions */
+ action_list_t::reverse_iterator rit = action_trace.rbegin();
+ for (; (*rit) != acquire; rit++) {
+ ModelAction *propagate = *rit;
+ if (acquire->happens_before(propagate)) {
+ synchronize(acquire, propagate);
+ /* Re-check 'propagate' for mo_graph edges */
+ work->push_back(MOEdgeWorkEntry(propagate));
+ }
+ }
+}
+
+/**
+ * Attempt to resolve all stashed operations that might synchronize with a
+ * release sequence for a given location. This implements the "lazy" portion of
+ * determining whether or not a release sequence was contiguous, since not all
+ * modification order information is present at the time an action occurs.
+ *
+ * @param location The location/object that should be checked for release
+ * sequence resolutions. A NULL value means to check all locations.
+ * @param work_queue The work queue to which to add work items as they are
+ * generated
+ * @return True if any updates occurred (new synchronization, new mo_graph
+ * edges)
+ */
+bool ModelExecution::resolve_release_sequences(void *location, work_queue_t *work_queue)
+{
+ bool updated = false;
+ SnapVector<struct release_seq *>::iterator it = pending_rel_seqs.begin();
+ while (it != pending_rel_seqs.end()) {
+ struct release_seq *pending = *it;
+ ModelAction *acquire = pending->acquire;
+ const ModelAction *read = pending->read;
+
+ /* Only resolve sequences on the given location, if provided */
+ if (location && read->get_location() != location) {
+ it++;
+ continue;
+ }
+
+ const ModelAction *rf = read->get_reads_from();
+ rel_heads_list_t release_heads;
+ bool complete;
+ complete = release_seq_heads(rf, &release_heads, pending);
+ for (unsigned int i = 0; i < release_heads.size(); i++)
+ if (!acquire->has_synchronized_with(release_heads[i]))
+ if (synchronize(release_heads[i], acquire))
+ updated = true;
+
+ if (updated) {
+ /* Propagate the changed clock vector */
+ propagate_clockvector(acquire, work_queue);
+ }
+ if (complete) {
+ it = pending_rel_seqs.erase(it);
+ snapshot_free(pending);
+ } else {
+ it++;
+ }
+ }
+
+ // If we resolved promises or data races, see if we have realized a data race.
+ checkDataRaces();
+
+ return updated;
+}
+
+/**
+ * Performs various bookkeeping operations for the current ModelAction. For
+ * instance, adds action to the per-object, per-thread action vector and to the
+ * action trace list of all thread actions.
+ *
+ * @param act is the ModelAction to add.
+ */
+void ModelExecution::add_action_to_lists(ModelAction *act)
+{
+ int tid = id_to_int(act->get_tid());
+ ModelAction *uninit = NULL;
+ int uninit_id = -1;
+ action_list_t *list = get_safe_ptr_action(&obj_map, act->get_location());
+ if (list->empty() && act->is_atomic_var()) {
+ uninit = get_uninitialized_action(act);
+ uninit_id = id_to_int(uninit->get_tid());
+ list->push_front(uninit);
+ }
+ list->push_back(act);
+
+ action_trace.push_back(act);
+ if (uninit)
+ action_trace.push_front(uninit);
+
+ SnapVector<action_list_t> *vec = get_safe_ptr_vect_action(&obj_thrd_map, act->get_location());
+ if (tid >= (int)vec->size())
+ vec->resize(priv->next_thread_id);
+ (*vec)[tid].push_back(act);
+ if (uninit)
+ (*vec)[uninit_id].push_front(uninit);
+
+ if ((int)thrd_last_action.size() <= tid)
+ thrd_last_action.resize(get_num_threads());
+ thrd_last_action[tid] = act;
+ if (uninit)
+ thrd_last_action[uninit_id] = uninit;
+
+ if (act->is_fence() && act->is_release()) {
+ if ((int)thrd_last_fence_release.size() <= tid)
+ thrd_last_fence_release.resize(get_num_threads());
+ thrd_last_fence_release[tid] = act;
+ }
+
+ if (act->is_wait()) {
+ void *mutex_loc = (void *) act->get_value();
+ get_safe_ptr_action(&obj_map, mutex_loc)->push_back(act);
+
+ SnapVector<action_list_t> *vec = get_safe_ptr_vect_action(&obj_thrd_map, mutex_loc);
+ if (tid >= (int)vec->size())
+ vec->resize(priv->next_thread_id);
+ (*vec)[tid].push_back(act);
+ }
+}
+
+/**
+ * @brief Get the last action performed by a particular Thread
+ * @param tid The thread ID of the Thread in question
+ * @return The last action in the thread
+ */
+ModelAction * ModelExecution::get_last_action(thread_id_t tid) const
+{
+ int threadid = id_to_int(tid);
+ if (threadid < (int)thrd_last_action.size())
+ return thrd_last_action[id_to_int(tid)];
+ else
+ return NULL;
+}
+
+/**
+ * @brief Get the last fence release performed by a particular Thread
+ * @param tid The thread ID of the Thread in question
+ * @return The last fence release in the thread, if one exists; NULL otherwise
+ */
+ModelAction * ModelExecution::get_last_fence_release(thread_id_t tid) const
+{
+ int threadid = id_to_int(tid);
+ if (threadid < (int)thrd_last_fence_release.size())
+ return thrd_last_fence_release[id_to_int(tid)];
+ else
+ return NULL;
+}
+
+/**
+ * Gets the last memory_order_seq_cst write (in the total global sequence)
+ * performed on a particular object (i.e., memory location), not including the
+ * current action.
+ * @param curr The current ModelAction; also denotes the object location to
+ * check
+ * @return The last seq_cst write
+ */
+ModelAction * ModelExecution::get_last_seq_cst_write(ModelAction *curr) const
+{
+ void *location = curr->get_location();
+ action_list_t *list = obj_map.get(location);
+ /* Find: max({i in dom(S) | seq_cst(t_i) && isWrite(t_i) && samevar(t_i, t)}) */
+ action_list_t::reverse_iterator rit;
+ for (rit = list->rbegin(); (*rit) != curr; rit++)
+ ;
+ rit++; /* Skip past curr */
+ for ( ; rit != list->rend(); rit++)
+ if ((*rit)->is_write() && (*rit)->is_seqcst())
+ return *rit;
+ return NULL;
+}
+
+/**
+ * Gets the last memory_order_seq_cst fence (in the total global sequence)
+ * performed in a particular thread, prior to a particular fence.
+ * @param tid The ID of the thread to check
+ * @param before_fence The fence from which to begin the search; if NULL, then
+ * search for the most recent fence in the thread.
+ * @return The last prior seq_cst fence in the thread, if exists; otherwise, NULL
+ */
+ModelAction * ModelExecution::get_last_seq_cst_fence(thread_id_t tid, const ModelAction *before_fence) const
+{
+ /* All fences should have location FENCE_LOCATION */
+ action_list_t *list = obj_map.get(FENCE_LOCATION);
+
+ if (!list)
+ return NULL;
+
+ action_list_t::reverse_iterator rit = list->rbegin();
+
+ if (before_fence) {
+ for (; rit != list->rend(); rit++)
+ if (*rit == before_fence)
+ break;
+
+ ASSERT(*rit == before_fence);
+ rit++;
+ }
+
+ for (; rit != list->rend(); rit++)
+ if ((*rit)->is_fence() && (tid == (*rit)->get_tid()) && (*rit)->is_seqcst())
+ return *rit;
+ return NULL;
+}
+
+/**
+ * Gets the last unlock operation performed on a particular mutex (i.e., memory
+ * location). This function identifies the mutex according to the current
+ * action, which is presumed to perform on the same mutex.
+ * @param curr The current ModelAction; also denotes the object location to
+ * check
+ * @return The last unlock operation
+ */
+ModelAction * ModelExecution::get_last_unlock(ModelAction *curr) const
+{
+ void *location = curr->get_location();
+ action_list_t *list = obj_map.get(location);
+ /* Find: max({i in dom(S) | isUnlock(t_i) && samevar(t_i, t)}) */
+ action_list_t::reverse_iterator rit;
+ for (rit = list->rbegin(); rit != list->rend(); rit++)
+ if ((*rit)->is_unlock() || (*rit)->is_wait())
+ return *rit;
+ return NULL;
+}
+
+ModelAction * ModelExecution::get_parent_action(thread_id_t tid) const
+{
+ ModelAction *parent = get_last_action(tid);
+ if (!parent)
+ parent = get_thread(tid)->get_creation();
+ return parent;
+}
+
+/**
+ * Returns the clock vector for a given thread.
+ * @param tid The thread whose clock vector we want
+ * @return Desired clock vector
+ */
+ClockVector * ModelExecution::get_cv(thread_id_t tid) const
+{
+ return get_parent_action(tid)->get_cv();
+}
+
+/**
+ * @brief Find the promise (if any) to resolve for the current action and
+ * remove it from the pending promise vector
+ * @param curr The current ModelAction. Should be a write.
+ * @return The Promise to resolve, if any; otherwise NULL
+ */
+Promise * ModelExecution::pop_promise_to_resolve(const ModelAction *curr)
+{
+ for (unsigned int i = 0; i < promises.size(); i++)
+ if (curr->get_node()->get_promise(i)) {
+ Promise *ret = promises[i];
+ promises.erase(promises.begin() + i);
+ return ret;
+ }
+ return NULL;
+}
+
+/**
+ * Resolve a Promise with a current write.
+ * @param write The ModelAction that is fulfilling Promises
+ * @param promise The Promise to resolve
+ * @param work The work queue, for adding new fixup work
+ * @return True if the Promise was successfully resolved; false otherwise
+ */
+bool ModelExecution::resolve_promise(ModelAction *write, Promise *promise,
+ work_queue_t *work)
+{
+ ModelVector<ModelAction *> actions_to_check;
+
+ for (unsigned int i = 0; i < promise->get_num_readers(); i++) {
+ ModelAction *read = promise->get_reader(i);
+ if (read_from(read, write)) {
+ /* Propagate the changed clock vector */
+ propagate_clockvector(read, work);
+ }
+ actions_to_check.push_back(read);
+ }
+ /* Make sure the promise's value matches the write's value */
+ ASSERT(promise->is_compatible(write) && promise->same_value(write));
+ if (!mo_graph->resolvePromise(promise, write))
+ priv->failed_promise = true;
+
+ /**
+ * @todo It is possible to end up in an inconsistent state, where a
+ * "resolved" promise may still be referenced if
+ * CycleGraph::resolvePromise() failed, so don't delete 'promise'.
+ *
+ * Note that the inconsistency only matters when dumping mo_graph to
+ * file.
+ *
+ * delete promise;
+ */
+
+ //Check whether reading these writes has made threads unable to
+ //resolve promises
+ for (unsigned int i = 0; i < actions_to_check.size(); i++) {
+ ModelAction *read = actions_to_check[i];
+ mo_check_promises(read, true);
+ }
+
+ return true;
+}
+
+/**
+ * Compute the set of promises that could potentially be satisfied by this
+ * action. Note that the set computation actually appears in the Node, not in
+ * ModelExecution.
+ * @param curr The ModelAction that may satisfy promises
+ */
+void ModelExecution::compute_promises(ModelAction *curr)
+{
+ for (unsigned int i = 0; i < promises.size(); i++) {
+ Promise *promise = promises[i];
+ if (!promise->is_compatible(curr) || !promise->same_value(curr))
+ continue;
+
+ bool satisfy = true;
+ for (unsigned int j = 0; j < promise->get_num_readers(); j++) {
+ const ModelAction *act = promise->get_reader(j);
+ if (act->happens_before(curr) ||
+ act->could_synchronize_with(curr)) {
+ satisfy = false;
+ break;
+ }
+ }
+ if (satisfy)
+ curr->get_node()->set_promise(i);
+ }
+}
+
+/** Checks promises in response to change in ClockVector Threads. */
+void ModelExecution::check_promises(thread_id_t tid, ClockVector *old_cv, ClockVector *merge_cv)
+{
+ for (unsigned int i = 0; i < promises.size(); i++) {
+ Promise *promise = promises[i];
+ if (!promise->thread_is_available(tid))
+ continue;
+ for (unsigned int j = 0; j < promise->get_num_readers(); j++) {
+ const ModelAction *act = promise->get_reader(j);
+ if ((!old_cv || !old_cv->synchronized_since(act)) &&
+ merge_cv->synchronized_since(act)) {
+ if (promise->eliminate_thread(tid)) {
+ /* Promise has failed */
+ priv->failed_promise = true;
+ return;
+ }
+ }
+ }
+ }
+}
+
+void ModelExecution::check_promises_thread_disabled()
+{
+ for (unsigned int i = 0; i < promises.size(); i++) {
+ Promise *promise = promises[i];
+ if (promise->has_failed()) {
+ priv->failed_promise = true;
+ return;
+ }
+ }
+}
+
+/**
+ * @brief Checks promises in response to addition to modification order for
+ * threads.
+ *
+ * We test whether threads are still available for satisfying promises after an
+ * addition to our modification order constraints. Those that are unavailable
+ * are "eliminated". Once all threads are eliminated from satisfying a promise,
+ * that promise has failed.
+ *
+ * @param act The ModelAction which updated the modification order
+ * @param is_read_check Should be true if act is a read and we must check for
+ * updates to the store from which it read (there is a distinction here for
+ * RMW's, which are both a load and a store)
+ */
+void ModelExecution::mo_check_promises(const ModelAction *act, bool is_read_check)
+{
+ const ModelAction *write = is_read_check ? act->get_reads_from() : act;
+
+ for (unsigned int i = 0; i < promises.size(); i++) {
+ Promise *promise = promises[i];
+
+ // Is this promise on the same location?
+ if (!promise->same_location(write))
+ continue;
+
+ for (unsigned int j = 0; j < promise->get_num_readers(); j++) {
+ const ModelAction *pread = promise->get_reader(j);
+ if (!pread->happens_before(act))
+ continue;
+ if (mo_graph->checkPromise(write, promise)) {
+ priv->failed_promise = true;
+ return;
+ }
+ break;
+ }
+
+ // Don't do any lookups twice for the same thread
+ if (!promise->thread_is_available(act->get_tid()))
+ continue;
+
+ if (mo_graph->checkReachable(promise, write)) {
+ if (mo_graph->checkPromise(write, promise)) {
+ priv->failed_promise = true;
+ return;
+ }
+ }
+ }
+}
+
+/**
+ * Compute the set of writes that may break the current pending release
+ * sequence. This information is extracted from previou release sequence
+ * calculations.
+ *
+ * @param curr The current ModelAction. Must be a release sequence fixup
+ * action.
+ */
+void ModelExecution::compute_relseq_breakwrites(ModelAction *curr)
+{
+ if (pending_rel_seqs.empty())
+ return;
+
+ struct release_seq *pending = pending_rel_seqs.back();
+ for (unsigned int i = 0; i < pending->writes.size(); i++) {
+ const ModelAction *write = pending->writes[i];
+ curr->get_node()->add_relseq_break(write);
+ }
+
+ /* NULL means don't break the sequence; just synchronize */
+ curr->get_node()->add_relseq_break(NULL);
+}
+
+/**
+ * Build up an initial set of all past writes that this 'read' action may read
+ * from, as well as any previously-observed future values that must still be valid.
+ *
+ * @param curr is the current ModelAction that we are exploring; it must be a
+ * 'read' operation.
+ */
+void ModelExecution::build_may_read_from(ModelAction *curr)
+{
+ SnapVector<action_list_t> *thrd_lists = obj_thrd_map.get(curr->get_location());
+ unsigned int i;
+ ASSERT(curr->is_read());
+
+ ModelAction *last_sc_write = NULL;
+
+ if (curr->is_seqcst())
+ last_sc_write = get_last_seq_cst_write(curr);
+
+ /* Iterate over all threads */
+ for (i = 0; i < thrd_lists->size(); i++) {
+ /* Iterate over actions in thread, starting from most recent */
+ action_list_t *list = &(*thrd_lists)[i];
+ action_list_t::reverse_iterator rit;
+ for (rit = list->rbegin(); rit != list->rend(); rit++) {
+ ModelAction *act = *rit;
+
+ /* Only consider 'write' actions */
+ if (!act->is_write() || act == curr)
+ continue;
+
+ /* Don't consider more than one seq_cst write if we are a seq_cst read. */
+ bool allow_read = true;
+
+ if (curr->is_seqcst() && (act->is_seqcst() || (last_sc_write != NULL && act->happens_before(last_sc_write))) && act != last_sc_write)
+ allow_read = false;
+ else if (curr->get_sleep_flag() && !curr->is_seqcst() && !sleep_can_read_from(curr, act))
+ allow_read = false;
+
+ if (allow_read) {
+ /* Only add feasible reads */
+ mo_graph->startChanges();
+ r_modification_order(curr, act);
+ if (!is_infeasible())
+ curr->get_node()->add_read_from_past(act);
+ mo_graph->rollbackChanges();
+ }
+
+ /* Include at most one act per-thread that "happens before" curr */
+ if (act->happens_before(curr))
+ break;
+ }
+ }
+
+ /* Inherit existing, promised future values */
+ for (i = 0; i < promises.size(); i++) {
+ const Promise *promise = promises[i];
+ const ModelAction *promise_read = promise->get_reader(0);
+ if (promise_read->same_var(curr)) {
+ /* Only add feasible future-values */
+ mo_graph->startChanges();
+ r_modification_order(curr, promise);
+ if (!is_infeasible())
+ curr->get_node()->add_read_from_promise(promise_read);
+ mo_graph->rollbackChanges();
+ }
+ }
+
+ /* We may find no valid may-read-from only if the execution is doomed */
+ if (!curr->get_node()->read_from_size()) {
+ priv->no_valid_reads = true;
+ set_assert();
+ }
+
+ if (DBG_ENABLED()) {
+ model_print("Reached read action:\n");
+ curr->print();
+ model_print("Printing read_from_past\n");
+ curr->get_node()->print_read_from_past();
+ model_print("End printing read_from_past\n");
+ }
+}
+
+bool ModelExecution::sleep_can_read_from(ModelAction *curr, const ModelAction *write)
+{
+ for ( ; write != NULL; write = write->get_reads_from()) {
+ /* UNINIT actions don't have a Node, and they never sleep */
+ if (write->is_uninitialized())
+ return true;
+ Node *prevnode = write->get_node()->get_parent();
+
+ bool thread_sleep = prevnode->enabled_status(curr->get_tid()) == THREAD_SLEEP_SET;
+ if (write->is_release() && thread_sleep)
+ return true;
+ if (!write->is_rmw())
+ return false;
+ }
+ return true;
+}
+
+/**
+ * @brief Get an action representing an uninitialized atomic
+ *
+ * This function may create a new one or try to retrieve one from the NodeStack
+ *
+ * @param curr The current action, which prompts the creation of an UNINIT action
+ * @return A pointer to the UNINIT ModelAction
+ */
+ModelAction * ModelExecution::get_uninitialized_action(const ModelAction *curr) const
+{
+ Node *node = curr->get_node();
+ ModelAction *act = node->get_uninit_action();
+ if (!act) {
+ act = new ModelAction(ATOMIC_UNINIT, std::memory_order_relaxed, curr->get_location(), params->uninitvalue, model_thread);
+ node->set_uninit_action(act);
+ }
+ act->create_cv(NULL);
+ return act;
+}
+
+static void print_list(const action_list_t *list)
+{
+ action_list_t::const_iterator it;
+
+ model_print("------------------------------------------------------------------------------------\n");
+ model_print("# t Action type MO Location Value Rf CV\n");
+ model_print("------------------------------------------------------------------------------------\n");
+
+ unsigned int hash = 0;
+
+ for (it = list->begin(); it != list->end(); it++) {
+ const ModelAction *act = *it;
+ if (act->get_seq_number() > 0)
+ act->print();
+ hash = hash^(hash<<3)^((*it)->hash());
+ }
+ model_print("HASH %u\n", hash);
+ model_print("------------------------------------------------------------------------------------\n");
+}
+
+#if SUPPORT_MOD_ORDER_DUMP
+void ModelExecution::dumpGraph(char *filename) const
+{
+ char buffer[200];
+ sprintf(buffer, "%s.dot", filename);
+ FILE *file = fopen(buffer, "w");
+ fprintf(file, "digraph %s {\n", filename);
+ mo_graph->dumpNodes(file);
+ ModelAction **thread_array = (ModelAction **)model_calloc(1, sizeof(ModelAction *) * get_num_threads());
+
+ for (action_list_t::const_iterator it = action_trace.begin(); it != action_trace.end(); it++) {
+ ModelAction *act = *it;
+ if (act->is_read()) {
+ mo_graph->dot_print_node(file, act);
+ if (act->get_reads_from())
+ mo_graph->dot_print_edge(file,
+ act->get_reads_from(),
+ act,
+ "label=\"rf\", color=red, weight=2");
+ else
+ mo_graph->dot_print_edge(file,
+ act->get_reads_from_promise(),
+ act,
+ "label=\"rf\", color=red");
+ }
+ if (thread_array[act->get_tid()]) {
+ mo_graph->dot_print_edge(file,
+ thread_array[id_to_int(act->get_tid())],
+ act,
+ "label=\"sb\", color=blue, weight=400");
+ }
+
+ thread_array[act->get_tid()] = act;
+ }
+ fprintf(file, "}\n");
+ model_free(thread_array);
+ fclose(file);
+}
+#endif
+
+/** @brief Prints an execution trace summary. */
+void ModelExecution::print_summary() const
+{
+#if SUPPORT_MOD_ORDER_DUMP
+ char buffername[100];
+ sprintf(buffername, "exec%04u", get_execution_number());
+ mo_graph->dumpGraphToFile(buffername);
+ sprintf(buffername, "graph%04u", get_execution_number());
+ dumpGraph(buffername);
+#endif
+
+ model_print("Execution trace %d:", get_execution_number());
+ if (isfeasibleprefix()) {
+ if (is_yieldblocked())
+ model_print(" YIELD BLOCKED");
+ if (scheduler->all_threads_sleeping())
+ model_print(" SLEEP-SET REDUNDANT");
+ if (have_bug_reports())
+ model_print(" DETECTED BUG(S)");
+ } else
+ print_infeasibility(" INFEASIBLE");
+ model_print("\n");
+
+ print_list(&action_trace);
+ model_print("\n");
+
+ if (!promises.empty()) {
+ model_print("Pending promises:\n");
+ for (unsigned int i = 0; i < promises.size(); i++) {
+ model_print(" [P%u] ", i);
+ promises[i]->print();
+ }
+ model_print("\n");
+ }
+}
+
+/**
+ * Add a Thread to the system for the first time. Should only be called once
+ * per thread.
+ * @param t The Thread to add
+ */
+void ModelExecution::add_thread(Thread *t)
+{
+ unsigned int i = id_to_int(t->get_id());
+ if (i >= thread_map.size())
+ thread_map.resize(i + 1);
+ thread_map[i] = t;
+ if (!t->is_model_thread())
+ scheduler->add_thread(t);
+}
+
+/**
+ * @brief Get a Thread reference by its ID
+ * @param tid The Thread's ID
+ * @return A Thread reference
+ */
+Thread * ModelExecution::get_thread(thread_id_t tid) const
+{
+ unsigned int i = id_to_int(tid);
+ if (i < thread_map.size())
+ return thread_map[i];
+ return NULL;
+}
+
+/**
+ * @brief Get a reference to the Thread in which a ModelAction was executed
+ * @param act The ModelAction
+ * @return A Thread reference
+ */
+Thread * ModelExecution::get_thread(const ModelAction *act) const
+{
+ return get_thread(act->get_tid());
+}
+
+/**
+ * @brief Get a Promise's "promise number"
+ *
+ * A "promise number" is an index number that is unique to a promise, valid
+ * only for a specific snapshot of an execution trace. Promises may come and go
+ * as they are generated an resolved, so an index only retains meaning for the
+ * current snapshot.
+ *
+ * @param promise The Promise to check
+ * @return The promise index, if the promise still is valid; otherwise -1
+ */
+int ModelExecution::get_promise_number(const Promise *promise) const
+{
+ for (unsigned int i = 0; i < promises.size(); i++)
+ if (promises[i] == promise)
+ return i;
+ /* Not found */
+ return -1;
+}
+
+/**
+ * @brief Check if a Thread is currently enabled
+ * @param t The Thread to check
+ * @return True if the Thread is currently enabled
+ */
+bool ModelExecution::is_enabled(Thread *t) const
+{
+ return scheduler->is_enabled(t);
+}
+
+/**
+ * @brief Check if a Thread is currently enabled
+ * @param tid The ID of the Thread to check
+ * @return True if the Thread is currently enabled
+ */
+bool ModelExecution::is_enabled(thread_id_t tid) const
+{
+ return scheduler->is_enabled(tid);
+}
+
+/**
+ * @brief Select the next thread to execute based on the curren action
+ *
+ * RMW actions occur in two parts, and we cannot split them. And THREAD_CREATE
+ * actions should be followed by the execution of their child thread. In either
+ * case, the current action should determine the next thread schedule.
+ *
+ * @param curr The current action
+ * @return The next thread to run, if the current action will determine this
+ * selection; otherwise NULL
+ */
+Thread * ModelExecution::action_select_next_thread(const ModelAction *curr) const
+{
+ /* Do not split atomic RMW */
+ if (curr->is_rmwr())
+ return get_thread(curr);
+ /* Follow CREATE with the created thread */
+ if (curr->get_type() == THREAD_CREATE)
+ return curr->get_thread_operand();
+ return NULL;
+}
+
+/** @return True if the execution has taken too many steps */
+bool ModelExecution::too_many_steps() const
+{
+ return params->bound != 0 && priv->used_sequence_numbers > params->bound;
+}
+
+/**
+ * Takes the next step in the execution, if possible.
+ * @param curr The current step to take
+ * @return Returns the next Thread to run, if any; NULL if this execution
+ * should terminate
+ */
+Thread * ModelExecution::take_step(ModelAction *curr)
+{
+ Thread *curr_thrd = get_thread(curr);
+ ASSERT(curr_thrd->get_state() == THREAD_READY);
+
+ ASSERT(check_action_enabled(curr)); /* May have side effects? */
+ curr = check_current_action(curr);
+ ASSERT(curr);
+
+ if (curr_thrd->is_blocked() || curr_thrd->is_complete())
+ scheduler->remove_thread(curr_thrd);
+
+ return action_select_next_thread(curr);
+}
+
+/**
+ * Launch end-of-execution release sequence fixups only when
+ * the execution is otherwise feasible AND there are:
+ *
+ * (1) pending release sequences
+ * (2) pending assertions that could be invalidated by a change
+ * in clock vectors (i.e., data races)
+ * (3) no pending promises
+ */
+void ModelExecution::fixup_release_sequences()
+{
+ while (!pending_rel_seqs.empty() &&
+ is_feasible_prefix_ignore_relseq() &&
+ haveUnrealizedRaces()) {
+ model_print("*** WARNING: release sequence fixup action "
+ "(%zu pending release seuqence(s)) ***\n",
+ pending_rel_seqs.size());
+ ModelAction *fixup = new ModelAction(MODEL_FIXUP_RELSEQ,
+ std::memory_order_seq_cst, NULL, VALUE_NONE,
+ model_thread);
+ take_step(fixup);
+ };
+}
--- /dev/null
+/** @file execution.h
+ * @brief Model-checker core
+ */
+
+#ifndef __EXECUTION_H__
+#define __EXECUTION_H__
+
+#include <cstddef>
+#include <inttypes.h>
+
+#include "mymemory.h"
+#include "hashtable.h"
+#include "workqueue.h"
+#include "config.h"
+#include "modeltypes.h"
+#include "stl-model.h"
+#include "params.h"
+
+/* Forward declaration */
+class Node;
+class NodeStack;
+class CycleGraph;
+class Promise;
+class Scheduler;
+class Thread;
+class ClockVector;
+struct model_snapshot_members;
+class ModelChecker;
+struct bug_message;
+
+/** @brief Shorthand for a list of release sequence heads */
+typedef ModelVector<const ModelAction *> rel_heads_list_t;
+typedef SnapList<ModelAction *> action_list_t;
+
+struct PendingFutureValue {
+ PendingFutureValue(ModelAction *writer, ModelAction *reader) :
+ writer(writer), reader(reader)
+ { }
+ const ModelAction *writer;
+ ModelAction *reader;
+};
+
+/** @brief Records information regarding a single pending release sequence */
+struct release_seq {
+ /** @brief The acquire operation */
+ ModelAction *acquire;
+ /** @brief The read operation that may read from a release sequence;
+ * may be the same as acquire, or else an earlier action in the same
+ * thread (i.e., when 'acquire' is a fence-acquire) */
+ const ModelAction *read;
+ /** @brief The head of the RMW chain from which 'read' reads; may be
+ * equal to 'release' */
+ const ModelAction *rf;
+ /** @brief The head of the potential longest release sequence chain */
+ const ModelAction *release;
+ /** @brief The write(s) that may break the release sequence */
+ SnapVector<const ModelAction *> writes;
+};
+
+/** @brief The central structure for model-checking */
+class ModelExecution {
+public:
+ ModelExecution(ModelChecker *m,
+ const struct model_params *params,
+ Scheduler *scheduler,
+ NodeStack *node_stack);
+ ~ModelExecution();
+
+ const struct model_params * get_params() const { return params; }
+
+ Thread * take_step(ModelAction *curr);
+ void fixup_release_sequences();
+
+ void print_summary() const;
+#if SUPPORT_MOD_ORDER_DUMP
+ void dumpGraph(char *filename) const;
+#endif
+
+ void add_thread(Thread *t);
+ Thread * get_thread(thread_id_t tid) const;
+ Thread * get_thread(const ModelAction *act) const;
+ int get_promise_number(const Promise *promise) const;
+
+ bool is_enabled(Thread *t) const;
+ bool is_enabled(thread_id_t tid) const;
+
+ thread_id_t get_next_id();
+ unsigned int get_num_threads() const;
+
+ ClockVector * get_cv(thread_id_t tid) const;
+ ModelAction * get_parent_action(thread_id_t tid) const;
+ void check_promises_thread_disabled();
+ bool isfeasibleprefix() const;
+
+ action_list_t * get_actions_on_obj(void * obj, thread_id_t tid) const;
+ ModelAction * get_last_action(thread_id_t tid) const;
+
+ bool check_action_enabled(ModelAction *curr);
+
+ bool assert_bug(const char *msg);
+ bool have_bug_reports() const;
+ SnapVector<bug_message *> * get_bugs() const;
+
+ bool has_asserted() const;
+ void set_assert();
+ bool is_complete_execution() const;
+
+ void print_infeasibility(const char *prefix) const;
+ bool is_feasible_prefix_ignore_relseq() const;
+ bool is_infeasible() const;
+ bool is_deadlocked() const;
+ bool is_yieldblocked() const;
+ bool too_many_steps() const;
+
+ ModelAction * get_next_backtrack();
+
+ action_list_t * get_action_trace() { return &action_trace; }
+
+ SNAPSHOTALLOC
+private:
+ int get_execution_number() const;
+
+ ModelChecker *model;
+
+ const model_params * const params;
+
+ /** The scheduler to use: tracks the running/ready Threads */
+ Scheduler * const scheduler;
+
+ bool sleep_can_read_from(ModelAction *curr, const ModelAction *write);
+ bool thin_air_constraint_may_allow(const ModelAction *writer, const ModelAction *reader) const;
+ bool mo_may_allow(const ModelAction *writer, const ModelAction *reader);
+ bool promises_may_allow(const ModelAction *writer, const ModelAction *reader) const;
+ void set_bad_synchronization();
+ bool promises_expired() const;
+ bool should_wake_up(const ModelAction *curr, const Thread *thread) const;
+ void wake_up_sleeping_actions(ModelAction *curr);
+ modelclock_t get_next_seq_num();
+
+ bool next_execution();
+ ModelAction * check_current_action(ModelAction *curr);
+ bool initialize_curr_action(ModelAction **curr);
+ bool process_read(ModelAction *curr);
+ bool process_write(ModelAction *curr, work_queue_t *work);
+ bool process_fence(ModelAction *curr);
+ bool process_mutex(ModelAction *curr);
+ bool process_thread_action(ModelAction *curr);
+ void process_relseq_fixup(ModelAction *curr, work_queue_t *work_queue);
+ bool read_from(ModelAction *act, const ModelAction *rf);
+ bool synchronize(const ModelAction *first, ModelAction *second);
+
+ template <typename T>
+ bool check_recency(ModelAction *curr, const T *rf) const;
+
+ template <typename T, typename U>
+ bool should_read_instead(const ModelAction *curr, const T *rf, const U *other_rf) const;
+
+ ModelAction * get_last_fence_conflict(ModelAction *act) const;
+ ModelAction * get_last_conflict(ModelAction *act) const;
+ void set_backtracking(ModelAction *act);
+ bool set_latest_backtrack(ModelAction *act);
+ Promise * pop_promise_to_resolve(const ModelAction *curr);
+ bool resolve_promise(ModelAction *curr, Promise *promise,
+ work_queue_t *work);
+ void compute_promises(ModelAction *curr);
+ void compute_relseq_breakwrites(ModelAction *curr);
+
+ void check_promises(thread_id_t tid, ClockVector *old_cv, ClockVector *merge_cv);
+ void mo_check_promises(const ModelAction *act, bool is_read_check);
+ void thread_blocking_check_promises(Thread *blocker, Thread *waiting);
+
+ void check_curr_backtracking(ModelAction *curr);
+ void add_action_to_lists(ModelAction *act);
+ ModelAction * get_last_fence_release(thread_id_t tid) const;
+ ModelAction * get_last_seq_cst_write(ModelAction *curr) const;
+ ModelAction * get_last_seq_cst_fence(thread_id_t tid, const ModelAction *before_fence) const;
+ ModelAction * get_last_unlock(ModelAction *curr) const;
+ void build_may_read_from(ModelAction *curr);
+ ModelAction * process_rmw(ModelAction *curr);
+
+ template <typename rf_type>
+ bool r_modification_order(ModelAction *curr, const rf_type *rf);
+
+ bool w_modification_order(ModelAction *curr, ModelVector<ModelAction *> *send_fv);
+ void get_release_seq_heads(ModelAction *acquire, ModelAction *read, rel_heads_list_t *release_heads);
+ bool release_seq_heads(const ModelAction *rf, rel_heads_list_t *release_heads, struct release_seq *pending) const;
+ void propagate_clockvector(ModelAction *acquire, work_queue_t *work);
+ bool resolve_release_sequences(void *location, work_queue_t *work_queue);
+ void add_future_value(const ModelAction *writer, ModelAction *reader);
+
+ ModelAction * get_uninitialized_action(const ModelAction *curr) const;
+
+ action_list_t action_trace;
+ SnapVector<Thread *> thread_map;
+
+ /** Per-object list of actions. Maps an object (i.e., memory location)
+ * to a trace of all actions performed on the object. */
+ HashTable<const void *, action_list_t *, uintptr_t, 4> obj_map;
+
+ /** Per-object list of actions. Maps an object (i.e., memory location)
+ * to a trace of all actions performed on the object. */
+ HashTable<const void *, action_list_t *, uintptr_t, 4> condvar_waiters_map;
+
+ HashTable<void *, SnapVector<action_list_t> *, uintptr_t, 4> obj_thrd_map;
+
+ /**
+ * @brief List of currently-pending promises
+ *
+ * Promises are sorted by the execution order of the read(s) which
+ * created them
+ */
+ SnapVector<Promise *> promises;
+ SnapVector<struct PendingFutureValue> futurevalues;
+
+ /**
+ * List of pending release sequences. Release sequences might be
+ * determined lazily as promises are fulfilled and modification orders
+ * are established. Each entry in the list may only be partially
+ * filled, depending on its pending status.
+ */
+ SnapVector<struct release_seq *> pending_rel_seqs;
+
+ SnapVector<ModelAction *> thrd_last_action;
+ SnapVector<ModelAction *> thrd_last_fence_release;
+ NodeStack * const node_stack;
+
+ /** A special model-checker Thread; used for associating with
+ * model-checker-related ModelAcitons */
+ Thread *model_thread;
+
+ /** Private data members that should be snapshotted. They are grouped
+ * together for efficiency and maintainability. */
+ struct model_snapshot_members * const priv;
+
+ /**
+ * @brief The modification order graph
+ *
+ * A directed acyclic graph recording observations of the modification
+ * order on all the atomic objects in the system. This graph should
+ * never contain any cycles, as that represents a violation of the
+ * memory model (total ordering). This graph really consists of many
+ * disjoint (unconnected) subgraphs, each graph corresponding to a
+ * separate ordering on a distinct object.
+ *
+ * The edges in this graph represent the "ordered before" relation,
+ * such that <tt>a --> b</tt> means <tt>a</tt> was ordered before
+ * <tt>b</tt>.
+ */
+ CycleGraph * const mo_graph;
+
+ Thread * action_select_next_thread(const ModelAction *curr) const;
+};
+
+#endif /* __EXECUTION_H__ */
--- /dev/null
+/** @file hashtable.h
+ * @brief Hashtable. Standard chained bucket variety.
+ */
+
+#ifndef __HASHTABLE_H__
+#define __HASHTABLE_H__
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "mymemory.h"
+#include "common.h"
+
+/**
+ * @brief HashTable node
+ *
+ * @tparam _Key Type name for the key
+ * @tparam _Val Type name for the values to be stored
+ */
+template<typename _Key, typename _Val>
+struct hashlistnode {
+ _Key key;
+ _Val val;
+};
+
+/**
+ * @brief A simple, custom hash table
+ *
+ * By default it is snapshotting, but you can pass in your own allocation
+ * functions. Note that this table does not support the value 0 (NULL) used as
+ * a key and is designed primarily with pointer-based keys in mind. Other
+ * primitive key types are supported only for non-zero values.
+ *
+ * @tparam _Key Type name for the key
+ * @tparam _Val Type name for the values to be stored
+ * @tparam _KeyInt Integer type that is at least as large as _Key. Used for key
+ * manipulation and storage.
+ * @tparam _Shift Logical shift to apply to all keys. Default 0.
+ * @tparam _malloc Provide your own 'malloc' for the table, or default to
+ * snapshotting.
+ * @tparam _calloc Provide your own 'calloc' for the table, or default to
+ * snapshotting.
+ * @tparam _free Provide your own 'free' for the table, or default to
+ * snapshotting.
+ */
+template<typename _Key, typename _Val, typename _KeyInt, int _Shift = 0, void * (* _malloc)(size_t) = snapshot_malloc, void * (* _calloc)(size_t, size_t) = snapshot_calloc, void (*_free)(void *) = snapshot_free>
+class HashTable {
+ public:
+ /**
+ * @brief Hash table constructor
+ * @param initialcapacity Sets the initial capacity of the hash table.
+ * Default size 1024.
+ * @param factor Sets the percentage full before the hashtable is
+ * resized. Default ratio 0.5.
+ */
+ HashTable(unsigned int initialcapacity = 1024, double factor = 0.5) {
+ // Allocate space for the hash table
+ table = (struct hashlistnode<_Key, _Val> *)_calloc(initialcapacity, sizeof(struct hashlistnode<_Key, _Val>));
+ loadfactor = factor;
+ capacity = initialcapacity;
+ capacitymask = initialcapacity - 1;
+
+ threshold = (unsigned int)(initialcapacity * loadfactor);
+ size = 0; // Initial number of elements in the hash
+ }
+
+ /** @brief Hash table destructor */
+ ~HashTable() {
+ _free(table);
+ }
+
+ /** Override: new operator */
+ void * operator new(size_t size) {
+ return _malloc(size);
+ }
+
+ /** Override: delete operator */
+ void operator delete(void *p, size_t size) {
+ _free(p);
+ }
+
+ /** Override: new[] operator */
+ void * operator new[](size_t size) {
+ return _malloc(size);
+ }
+
+ /** Override: delete[] operator */
+ void operator delete[](void *p, size_t size) {
+ _free(p);
+ }
+
+ /** @brief Reset the table to its initial state. */
+ void reset() {
+ memset(table, 0, capacity * sizeof(struct hashlistnode<_Key, _Val>));
+ size = 0;
+ }
+
+ /**
+ * @brief Put a key/value pair into the table
+ * @param key The key for the new value; must not be 0 or NULL
+ * @param val The value to store in the table
+ */
+ void put(_Key key, _Val val) {
+ /* HashTable cannot handle 0 as a key */
+ ASSERT(key);
+
+ if (size > threshold)
+ resize(capacity << 1);
+
+ struct hashlistnode<_Key, _Val> *search;
+
+ unsigned int index = ((_KeyInt)key) >> _Shift;
+ do {
+ index &= capacitymask;
+ search = &table[index];
+ if (search->key == key) {
+ search->val = val;
+ return;
+ }
+ index++;
+ } while (search->key);
+
+ search->key = key;
+ search->val = val;
+ size++;
+ }
+
+ /**
+ * @brief Lookup the corresponding value for the given key
+ * @param key The key for finding the value; must not be 0 or NULL
+ * @return The value in the table, if the key is found; otherwise 0
+ */
+ _Val get(_Key key) const {
+ struct hashlistnode<_Key, _Val> *search;
+
+ /* HashTable cannot handle 0 as a key */
+ ASSERT(key);
+
+ unsigned int index = ((_KeyInt)key) >> _Shift;
+ do {
+ index &= capacitymask;
+ search = &table[index];
+ if (search->key == key)
+ return search->val;
+ index++;
+ } while (search->key);
+ return (_Val)0;
+ }
+
+ /**
+ * @brief Check whether the table contains a value for the given key
+ * @param key The key for finding the value; must not be 0 or NULL
+ * @return True, if the key is found; false otherwise
+ */
+ bool contains(_Key key) const {
+ struct hashlistnode<_Key, _Val> *search;
+
+ /* HashTable cannot handle 0 as a key */
+ ASSERT(key);
+
+ unsigned int index = ((_KeyInt)key) >> _Shift;
+ do {
+ index &= capacitymask;
+ search = &table[index];
+ if (search->key == key)
+ return true;
+ index++;
+ } while (search->key);
+ return false;
+ }
+
+ /**
+ * @brief Resize the table
+ * @param newsize The new size of the table
+ */
+ void resize(unsigned int newsize) {
+ struct hashlistnode<_Key, _Val> *oldtable = table;
+ struct hashlistnode<_Key, _Val> *newtable;
+ unsigned int oldcapacity = capacity;
+
+ if ((newtable = (struct hashlistnode<_Key, _Val> *)_calloc(newsize, sizeof(struct hashlistnode<_Key, _Val>))) == NULL) {
+ model_print("calloc error %s %d\n", __FILE__, __LINE__);
+ exit(EXIT_FAILURE);
+ }
+
+ table = newtable; // Update the global hashtable upon resize()
+ capacity = newsize;
+ capacitymask = newsize - 1;
+
+ threshold = (unsigned int)(newsize * loadfactor);
+
+ struct hashlistnode<_Key, _Val> *bin = &oldtable[0];
+ struct hashlistnode<_Key, _Val> *lastbin = &oldtable[oldcapacity];
+ for (; bin < lastbin; bin++) {
+ _Key key = bin->key;
+
+ struct hashlistnode<_Key, _Val> *search;
+
+ unsigned int index = ((_KeyInt)key) >> _Shift;
+ do {
+ index &= capacitymask;
+ search = &table[index];
+ index++;
+ } while (search->key);
+
+ search->key = key;
+ search->val = bin->val;
+ }
+
+ _free(oldtable); // Free the memory of the old hash table
+ }
+
+ private:
+ struct hashlistnode<_Key, _Val> *table;
+ unsigned int capacity;
+ unsigned int size;
+ unsigned int capacitymask;
+ unsigned int threshold;
+ double loadfactor;
+};
+
+#endif /* __HASHTABLE_H__ */
--- /dev/null
+#include "impatomic.h"
+#include "common.h"
+#include "model.h"
+#include "threads-model.h"
+#include "action.h"
+
+namespace std {
+
+bool atomic_flag_test_and_set_explicit ( volatile atomic_flag * __a__, memory_order __x__ ) {
+ volatile bool * __p__ = &((__a__)->__f__);
+ bool result = (bool) model->switch_to_master(new ModelAction(ATOMIC_RMWR, __x__, (void *) __p__));
+ model->switch_to_master(new ModelAction(ATOMIC_RMW, __x__, (void *) __p__, true));
+ return result;
+}
+
+bool atomic_flag_test_and_set( volatile atomic_flag* __a__ )
+{ return atomic_flag_test_and_set_explicit( __a__, memory_order_seq_cst ); }
+
+void atomic_flag_clear_explicit
+( volatile atomic_flag* __a__, memory_order __x__ )
+{
+ volatile bool * __p__ = &((__a__)->__f__);
+ model->switch_to_master(new ModelAction(ATOMIC_WRITE, __x__, (void *) __p__, false));
+}
+
+void atomic_flag_clear( volatile atomic_flag* __a__ )
+{ atomic_flag_clear_explicit( __a__, memory_order_seq_cst ); }
+
+void __atomic_flag_wait__( volatile atomic_flag* __a__ )
+{ while ( atomic_flag_test_and_set( __a__ ) ); }
+
+void __atomic_flag_wait_explicit__( volatile atomic_flag* __a__,
+ memory_order __x__ )
+{ while ( atomic_flag_test_and_set_explicit( __a__, __x__ ) ); }
+
+}
--- /dev/null
+/**
+ * @file atomic
+ * @brief C++11 atomic interface header
+ */
+
+#ifndef __CXX_ATOMIC__
+#define __CXX_ATOMIC__
+
+#include "impatomic.h"
+
+#endif /* __CXX_ATOMIC__ */
--- /dev/null
+#ifndef CDS_ANNOTATE_H
+#define CDS_ANNOTATE_H
+#include <stdint.h>
+
+void cdsannotate(uint64_t analysistype, void *annotation);
+
+#endif
--- /dev/null
+/** @file cmodelint.h
+ * @brief C interface to the model checker.
+ */
+
+#ifndef CMODELINT_H
+#define CMODELINT_H
+#include <inttypes.h>
+#include "memoryorder.h"
+
+#if __cplusplus
+using std::memory_order;
+extern "C" {
+#endif
+
+uint64_t model_read_action(void * obj, memory_order ord);
+void model_write_action(void * obj, memory_order ord, uint64_t val);
+void model_init_action(void * obj, uint64_t val);
+uint64_t model_rmwr_action(void *obj, memory_order ord);
+void model_rmw_action(void *obj, memory_order ord, uint64_t val);
+void model_rmwc_action(void *obj, memory_order ord);
+void model_fence_action(memory_order ord);
+
+
+#if __cplusplus
+}
+#endif
+
+#endif
--- /dev/null
+#ifndef __CXX_CONDITION_VARIABLE__
+#define __CXX_CONDITION_VARIABLE__
+
+namespace std {
+ class mutex;
+
+ struct condition_variable_state {
+ int reserved;
+ };
+
+ class condition_variable {
+ public:
+ condition_variable();
+ ~condition_variable();
+ void notify_one();
+ void notify_all();
+ void wait(mutex& lock);
+
+ private:
+ struct condition_variable_state state;
+ };
+}
+
+#endif /* __CXX_CONDITION_VARIABLE__ */
--- /dev/null
+/**
+ * @file cstdatomic
+ * @brief C11 atomic interface header
+ */
+
+#include "impatomic.h"
+
--- /dev/null
+/**
+ * @file impatomic.h
+ * @brief Common header for C11/C++11 atomics
+ *
+ * Note that some features are unavailable, as they require support from a true
+ * C11/C++11 compiler.
+ */
+
+#ifndef __IMPATOMIC_H__
+#define __IMPATOMIC_H__
+
+#include "memoryorder.h"
+#include "cmodelint.h"
+
+#ifdef __cplusplus
+namespace std {
+#else
+#include <stdbool.h>
+#endif
+
+#define CPP0X( feature )
+
+typedef struct atomic_flag
+{
+#ifdef __cplusplus
+ bool test_and_set( memory_order = memory_order_seq_cst ) volatile;
+ void clear( memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_flag() = default; )
+ CPP0X( atomic_flag( const atomic_flag& ) = delete; )
+ atomic_flag& operator =( const atomic_flag& ) CPP0X(=delete);
+
+CPP0X(private:)
+#endif
+ bool __f__;
+} atomic_flag;
+
+#define ATOMIC_FLAG_INIT { false }
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern bool atomic_flag_test_and_set( volatile atomic_flag* );
+extern bool atomic_flag_test_and_set_explicit
+( volatile atomic_flag*, memory_order );
+extern void atomic_flag_clear( volatile atomic_flag* );
+extern void atomic_flag_clear_explicit
+( volatile atomic_flag*, memory_order );
+extern void __atomic_flag_wait__
+( volatile atomic_flag* );
+extern void __atomic_flag_wait_explicit__
+( volatile atomic_flag*, memory_order );
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+
+inline bool atomic_flag::test_and_set( memory_order __x__ ) volatile
+{ return atomic_flag_test_and_set_explicit( this, __x__ ); }
+
+inline void atomic_flag::clear( memory_order __x__ ) volatile
+{ atomic_flag_clear_explicit( this, __x__ ); }
+
+#endif
+
+
+/*
+ The remainder of the example implementation uses the following
+ macros. These macros exploit GNU extensions for value-returning
+ blocks (AKA statement expressions) and __typeof__.
+
+ The macros rely on data fields of atomic structs being named __f__.
+ Other symbols used are __a__=atomic, __e__=expected, __f__=field,
+ __g__=flag, __m__=modified, __o__=operation, __r__=result,
+ __p__=pointer to field, __v__=value (for single evaluation),
+ __x__=memory-ordering, and __y__=memory-ordering.
+*/
+
+#define _ATOMIC_LOAD_( __a__, __x__ ) \
+ ({ volatile __typeof__((__a__)->__f__)* __p__ = & ((__a__)->__f__); \
+ __typeof__((__a__)->__f__) __r__ = (__typeof__((__a__)->__f__))model_read_action((void *)__p__, __x__); \
+ __r__; })
+
+#define _ATOMIC_STORE_( __a__, __m__, __x__ ) \
+ ({ volatile __typeof__((__a__)->__f__)* __p__ = & ((__a__)->__f__); \
+ __typeof__(__m__) __v__ = (__m__); \
+ model_write_action((void *) __p__, __x__, (uint64_t) __v__); \
+ __v__ = __v__; /* Silence clang (-Wunused-value) */ \
+ })
+
+
+#define _ATOMIC_INIT_( __a__, __m__ ) \
+ ({ volatile __typeof__((__a__)->__f__)* __p__ = & ((__a__)->__f__); \
+ __typeof__(__m__) __v__ = (__m__); \
+ model_init_action((void *) __p__, (uint64_t) __v__); \
+ __v__ = __v__; /* Silence clang (-Wunused-value) */ \
+ })
+
+#define _ATOMIC_MODIFY_( __a__, __o__, __m__, __x__ ) \
+ ({ volatile __typeof__((__a__)->__f__)* __p__ = & ((__a__)->__f__); \
+ __typeof__((__a__)->__f__) __old__=(__typeof__((__a__)->__f__)) model_rmwr_action((void *)__p__, __x__); \
+ __typeof__(__m__) __v__ = (__m__); \
+ __typeof__((__a__)->__f__) __copy__= __old__; \
+ __copy__ __o__ __v__; \
+ model_rmw_action((void *)__p__, __x__, (uint64_t) __copy__); \
+ __old__ = __old__; /* Silence clang (-Wunused-value) */ \
+ })
+
+/* No spurious failure for now */
+#define _ATOMIC_CMPSWP_WEAK_ _ATOMIC_CMPSWP_
+
+#define _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ) \
+ ({ volatile __typeof__((__a__)->__f__)* __p__ = & ((__a__)->__f__); \
+ __typeof__(__e__) __q__ = (__e__); \
+ __typeof__(__m__) __v__ = (__m__); \
+ bool __r__; \
+ __typeof__((__a__)->__f__) __t__=(__typeof__((__a__)->__f__)) model_rmwr_action((void *)__p__, __x__); \
+ if (__t__ == * __q__ ) { \
+ model_rmw_action((void *)__p__, __x__, (uint64_t) __v__); __r__ = true; } \
+ else { model_rmwc_action((void *)__p__, __x__); *__q__ = __t__; __r__ = false;} \
+ __r__; })
+
+#define _ATOMIC_FENCE_( __x__ ) \
+ ({ model_fence_action(__x__);})
+
+
+#define ATOMIC_CHAR_LOCK_FREE 1
+#define ATOMIC_CHAR16_T_LOCK_FREE 1
+#define ATOMIC_CHAR32_T_LOCK_FREE 1
+#define ATOMIC_WCHAR_T_LOCK_FREE 1
+#define ATOMIC_SHORT_LOCK_FREE 1
+#define ATOMIC_INT_LOCK_FREE 1
+#define ATOMIC_LONG_LOCK_FREE 1
+#define ATOMIC_LLONG_LOCK_FREE 1
+#define ATOMIC_ADDRESS_LOCK_FREE 1
+
+typedef struct atomic_bool
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( bool, memory_order = memory_order_seq_cst ) volatile;
+ bool load( memory_order = memory_order_seq_cst ) volatile;
+ bool exchange( bool, memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak ( bool&, bool, memory_order, memory_order ) volatile;
+ bool compare_exchange_strong ( bool&, bool, memory_order, memory_order ) volatile;
+ bool compare_exchange_weak ( bool&, bool,
+ memory_order = memory_order_seq_cst) volatile;
+ bool compare_exchange_strong ( bool&, bool,
+ memory_order = memory_order_seq_cst) volatile;
+
+ CPP0X( atomic_bool() = delete; )
+ CPP0X( constexpr explicit atomic_bool( bool __v__ ) : __f__( __v__ ) { } )
+ CPP0X( atomic_bool( const atomic_bool& ) = delete; )
+ atomic_bool& operator =( const atomic_bool& ) CPP0X(=delete);
+
+ bool operator =( bool __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_bool*, bool,
+ memory_order );
+ friend bool atomic_load_explicit( volatile atomic_bool*, memory_order );
+ friend bool atomic_exchange_explicit( volatile atomic_bool*, bool,
+ memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_bool*, bool*, bool,
+ memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_bool*, bool*, bool,
+ memory_order, memory_order );
+
+CPP0X(private:)
+#endif
+ bool __f__;
+} atomic_bool;
+
+
+typedef struct atomic_address
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( void*, memory_order = memory_order_seq_cst ) volatile;
+ void* load( memory_order = memory_order_seq_cst ) volatile;
+ void* exchange( void*, memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( void*&, void*, memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( void*&, void*, memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( void*&, void*,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( void*&, void*,
+ memory_order = memory_order_seq_cst ) volatile;
+ void* fetch_add( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
+ void* fetch_sub( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_address() = default; )
+ CPP0X( constexpr explicit atomic_address( void* __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_address( const atomic_address& ) = delete; )
+ atomic_address& operator =( const atomic_address & ) CPP0X(=delete);
+
+ void* operator =( void* __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ void* operator +=( ptrdiff_t __v__ ) volatile
+ { return fetch_add( __v__ ); }
+
+ void* operator -=( ptrdiff_t __v__ ) volatile
+ { return fetch_sub( __v__ ); }
+
+ friend void atomic_store_explicit( volatile atomic_address*, void*,
+ memory_order );
+ friend void* atomic_load_explicit( volatile atomic_address*, memory_order );
+ friend void* atomic_exchange_explicit( volatile atomic_address*, void*,
+ memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_address*,
+ void**, void*, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_address*,
+ void**, void*, memory_order, memory_order );
+ friend void* atomic_fetch_add_explicit( volatile atomic_address*, ptrdiff_t,
+ memory_order );
+ friend void* atomic_fetch_sub_explicit( volatile atomic_address*, ptrdiff_t,
+ memory_order );
+
+CPP0X(private:)
+#endif
+ void* __f__;
+} atomic_address;
+
+
+typedef struct atomic_char
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( char,
+ memory_order = memory_order_seq_cst ) volatile;
+ char load( memory_order = memory_order_seq_cst ) volatile;
+ char exchange( char,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( char&, char,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( char&, char,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( char&, char,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( char&, char,
+ memory_order = memory_order_seq_cst ) volatile;
+ char fetch_add( char,
+ memory_order = memory_order_seq_cst ) volatile;
+ char fetch_sub( char,
+ memory_order = memory_order_seq_cst ) volatile;
+ char fetch_and( char,
+ memory_order = memory_order_seq_cst ) volatile;
+ char fetch_or( char,
+ memory_order = memory_order_seq_cst ) volatile;
+ char fetch_xor( char,
+ memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_char() = default; )
+ CPP0X( constexpr atomic_char( char __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_char( const atomic_char& ) = delete; )
+ atomic_char& operator =( const atomic_char& ) CPP0X(=delete);
+
+ char operator =( char __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ char operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ char operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ char operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ char operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ char operator +=( char __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ char operator -=( char __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+
+ char operator &=( char __v__ ) volatile
+ { return fetch_and( __v__ ) & __v__; }
+
+ char operator |=( char __v__ ) volatile
+ { return fetch_or( __v__ ) | __v__; }
+
+ char operator ^=( char __v__ ) volatile
+ { return fetch_xor( __v__ ) ^ __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_char*, char,
+ memory_order );
+ friend char atomic_load_explicit( volatile atomic_char*,
+ memory_order );
+ friend char atomic_exchange_explicit( volatile atomic_char*,
+ char, memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_char*,
+ char*, char, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_char*,
+ char*, char, memory_order, memory_order );
+ friend char atomic_fetch_add_explicit( volatile atomic_char*,
+ char, memory_order );
+ friend char atomic_fetch_sub_explicit( volatile atomic_char*,
+ char, memory_order );
+ friend char atomic_fetch_and_explicit( volatile atomic_char*,
+ char, memory_order );
+ friend char atomic_fetch_or_explicit( volatile atomic_char*,
+ char, memory_order );
+ friend char atomic_fetch_xor_explicit( volatile atomic_char*,
+ char, memory_order );
+
+CPP0X(private:)
+#endif
+ char __f__;
+} atomic_char;
+
+
+typedef struct atomic_schar
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( signed char,
+ memory_order = memory_order_seq_cst ) volatile;
+ signed char load( memory_order = memory_order_seq_cst ) volatile;
+ signed char exchange( signed char,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( signed char&, signed char,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( signed char&, signed char,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( signed char&, signed char,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( signed char&, signed char,
+ memory_order = memory_order_seq_cst ) volatile;
+ signed char fetch_add( signed char,
+ memory_order = memory_order_seq_cst ) volatile;
+ signed char fetch_sub( signed char,
+ memory_order = memory_order_seq_cst ) volatile;
+ signed char fetch_and( signed char,
+ memory_order = memory_order_seq_cst ) volatile;
+ signed char fetch_or( signed char,
+ memory_order = memory_order_seq_cst ) volatile;
+ signed char fetch_xor( signed char,
+ memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_schar() = default; )
+ CPP0X( constexpr atomic_schar( signed char __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_schar( const atomic_schar& ) = delete; )
+ atomic_schar& operator =( const atomic_schar& ) CPP0X(=delete);
+
+ signed char operator =( signed char __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ signed char operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ signed char operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ signed char operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ signed char operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ signed char operator +=( signed char __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ signed char operator -=( signed char __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+
+ signed char operator &=( signed char __v__ ) volatile
+ { return fetch_and( __v__ ) & __v__; }
+
+ signed char operator |=( signed char __v__ ) volatile
+ { return fetch_or( __v__ ) | __v__; }
+
+ signed char operator ^=( signed char __v__ ) volatile
+ { return fetch_xor( __v__ ) ^ __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_schar*, signed char,
+ memory_order );
+ friend signed char atomic_load_explicit( volatile atomic_schar*,
+ memory_order );
+ friend signed char atomic_exchange_explicit( volatile atomic_schar*,
+ signed char, memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_schar*,
+ signed char*, signed char, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_schar*,
+ signed char*, signed char, memory_order, memory_order );
+ friend signed char atomic_fetch_add_explicit( volatile atomic_schar*,
+ signed char, memory_order );
+ friend signed char atomic_fetch_sub_explicit( volatile atomic_schar*,
+ signed char, memory_order );
+ friend signed char atomic_fetch_and_explicit( volatile atomic_schar*,
+ signed char, memory_order );
+ friend signed char atomic_fetch_or_explicit( volatile atomic_schar*,
+ signed char, memory_order );
+ friend signed char atomic_fetch_xor_explicit( volatile atomic_schar*,
+ signed char, memory_order );
+
+CPP0X(private:)
+#endif
+ signed char __f__;
+} atomic_schar;
+
+
+typedef struct atomic_uchar
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( unsigned char,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned char load( memory_order = memory_order_seq_cst ) volatile;
+ unsigned char exchange( unsigned char,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( unsigned char&, unsigned char,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( unsigned char&, unsigned char,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( unsigned char&, unsigned char,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( unsigned char&, unsigned char,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned char fetch_add( unsigned char,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned char fetch_sub( unsigned char,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned char fetch_and( unsigned char,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned char fetch_or( unsigned char,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned char fetch_xor( unsigned char,
+ memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_uchar() = default; )
+ CPP0X( constexpr atomic_uchar( unsigned char __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_uchar( const atomic_uchar& ) = delete; )
+ atomic_uchar& operator =( const atomic_uchar& ) CPP0X(=delete);
+
+ unsigned char operator =( unsigned char __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ unsigned char operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ unsigned char operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ unsigned char operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ unsigned char operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ unsigned char operator +=( unsigned char __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ unsigned char operator -=( unsigned char __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+
+ unsigned char operator &=( unsigned char __v__ ) volatile
+ { return fetch_and( __v__ ) & __v__; }
+
+ unsigned char operator |=( unsigned char __v__ ) volatile
+ { return fetch_or( __v__ ) | __v__; }
+
+ unsigned char operator ^=( unsigned char __v__ ) volatile
+ { return fetch_xor( __v__ ) ^ __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_uchar*, unsigned char,
+ memory_order );
+ friend unsigned char atomic_load_explicit( volatile atomic_uchar*,
+ memory_order );
+ friend unsigned char atomic_exchange_explicit( volatile atomic_uchar*,
+ unsigned char, memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_uchar*,
+ unsigned char*, unsigned char, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_uchar*,
+ unsigned char*, unsigned char, memory_order, memory_order );
+ friend unsigned char atomic_fetch_add_explicit( volatile atomic_uchar*,
+ unsigned char, memory_order );
+ friend unsigned char atomic_fetch_sub_explicit( volatile atomic_uchar*,
+ unsigned char, memory_order );
+ friend unsigned char atomic_fetch_and_explicit( volatile atomic_uchar*,
+ unsigned char, memory_order );
+ friend unsigned char atomic_fetch_or_explicit( volatile atomic_uchar*,
+ unsigned char, memory_order );
+ friend unsigned char atomic_fetch_xor_explicit( volatile atomic_uchar*,
+ unsigned char, memory_order );
+
+CPP0X(private:)
+#endif
+ unsigned char __f__;
+} atomic_uchar;
+
+
+typedef struct atomic_short
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( short,
+ memory_order = memory_order_seq_cst ) volatile;
+ short load( memory_order = memory_order_seq_cst ) volatile;
+ short exchange( short,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( short&, short,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( short&, short,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( short&, short,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( short&, short,
+ memory_order = memory_order_seq_cst ) volatile;
+ short fetch_add( short,
+ memory_order = memory_order_seq_cst ) volatile;
+ short fetch_sub( short,
+ memory_order = memory_order_seq_cst ) volatile;
+ short fetch_and( short,
+ memory_order = memory_order_seq_cst ) volatile;
+ short fetch_or( short,
+ memory_order = memory_order_seq_cst ) volatile;
+ short fetch_xor( short,
+ memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_short() = default; )
+ CPP0X( constexpr atomic_short( short __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_short( const atomic_short& ) = delete; )
+ atomic_short& operator =( const atomic_short& ) CPP0X(=delete);
+
+ short operator =( short __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ short operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ short operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ short operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ short operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ short operator +=( short __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ short operator -=( short __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+
+ short operator &=( short __v__ ) volatile
+ { return fetch_and( __v__ ) & __v__; }
+
+ short operator |=( short __v__ ) volatile
+ { return fetch_or( __v__ ) | __v__; }
+
+ short operator ^=( short __v__ ) volatile
+ { return fetch_xor( __v__ ) ^ __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_short*, short,
+ memory_order );
+ friend short atomic_load_explicit( volatile atomic_short*,
+ memory_order );
+ friend short atomic_exchange_explicit( volatile atomic_short*,
+ short, memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_short*,
+ short*, short, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_short*,
+ short*, short, memory_order, memory_order );
+ friend short atomic_fetch_add_explicit( volatile atomic_short*,
+ short, memory_order );
+ friend short atomic_fetch_sub_explicit( volatile atomic_short*,
+ short, memory_order );
+ friend short atomic_fetch_and_explicit( volatile atomic_short*,
+ short, memory_order );
+ friend short atomic_fetch_or_explicit( volatile atomic_short*,
+ short, memory_order );
+ friend short atomic_fetch_xor_explicit( volatile atomic_short*,
+ short, memory_order );
+
+CPP0X(private:)
+#endif
+ short __f__;
+} atomic_short;
+
+
+typedef struct atomic_ushort
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( unsigned short,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned short load( memory_order = memory_order_seq_cst ) volatile;
+ unsigned short exchange( unsigned short,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( unsigned short&, unsigned short,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( unsigned short&, unsigned short,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( unsigned short&, unsigned short,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( unsigned short&, unsigned short,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned short fetch_add( unsigned short,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned short fetch_sub( unsigned short,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned short fetch_and( unsigned short,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned short fetch_or( unsigned short,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned short fetch_xor( unsigned short,
+ memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_ushort() = default; )
+ CPP0X( constexpr atomic_ushort( unsigned short __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_ushort( const atomic_ushort& ) = delete; )
+ atomic_ushort& operator =( const atomic_ushort& ) CPP0X(=delete);
+
+ unsigned short operator =( unsigned short __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ unsigned short operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ unsigned short operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ unsigned short operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ unsigned short operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ unsigned short operator +=( unsigned short __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ unsigned short operator -=( unsigned short __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+
+ unsigned short operator &=( unsigned short __v__ ) volatile
+ { return fetch_and( __v__ ) & __v__; }
+
+ unsigned short operator |=( unsigned short __v__ ) volatile
+ { return fetch_or( __v__ ) | __v__; }
+
+ unsigned short operator ^=( unsigned short __v__ ) volatile
+ { return fetch_xor( __v__ ) ^ __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_ushort*, unsigned short,
+ memory_order );
+ friend unsigned short atomic_load_explicit( volatile atomic_ushort*,
+ memory_order );
+ friend unsigned short atomic_exchange_explicit( volatile atomic_ushort*,
+ unsigned short, memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_ushort*,
+ unsigned short*, unsigned short, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_ushort*,
+ unsigned short*, unsigned short, memory_order, memory_order );
+ friend unsigned short atomic_fetch_add_explicit( volatile atomic_ushort*,
+ unsigned short, memory_order );
+ friend unsigned short atomic_fetch_sub_explicit( volatile atomic_ushort*,
+ unsigned short, memory_order );
+ friend unsigned short atomic_fetch_and_explicit( volatile atomic_ushort*,
+ unsigned short, memory_order );
+ friend unsigned short atomic_fetch_or_explicit( volatile atomic_ushort*,
+ unsigned short, memory_order );
+ friend unsigned short atomic_fetch_xor_explicit( volatile atomic_ushort*,
+ unsigned short, memory_order );
+
+CPP0X(private:)
+#endif
+ unsigned short __f__;
+} atomic_ushort;
+
+
+typedef struct atomic_int
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( int,
+ memory_order = memory_order_seq_cst ) volatile;
+ int load( memory_order = memory_order_seq_cst ) volatile;
+ int exchange( int,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( int&, int,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( int&, int,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( int&, int,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( int&, int,
+ memory_order = memory_order_seq_cst ) volatile;
+ int fetch_add( int,
+ memory_order = memory_order_seq_cst ) volatile;
+ int fetch_sub( int,
+ memory_order = memory_order_seq_cst ) volatile;
+ int fetch_and( int,
+ memory_order = memory_order_seq_cst ) volatile;
+ int fetch_or( int,
+ memory_order = memory_order_seq_cst ) volatile;
+ int fetch_xor( int,
+ memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_int() = default; )
+ CPP0X( constexpr atomic_int( int __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_int( const atomic_int& ) = delete; )
+ atomic_int& operator =( const atomic_int& ) CPP0X(=delete);
+
+ int operator =( int __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ int operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ int operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ int operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ int operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ int operator +=( int __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ int operator -=( int __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+
+ int operator &=( int __v__ ) volatile
+ { return fetch_and( __v__ ) & __v__; }
+
+ int operator |=( int __v__ ) volatile
+ { return fetch_or( __v__ ) | __v__; }
+
+ int operator ^=( int __v__ ) volatile
+ { return fetch_xor( __v__ ) ^ __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_int*, int,
+ memory_order );
+ friend int atomic_load_explicit( volatile atomic_int*,
+ memory_order );
+ friend int atomic_exchange_explicit( volatile atomic_int*,
+ int, memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_int*,
+ int*, int, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_int*,
+ int*, int, memory_order, memory_order );
+ friend int atomic_fetch_add_explicit( volatile atomic_int*,
+ int, memory_order );
+ friend int atomic_fetch_sub_explicit( volatile atomic_int*,
+ int, memory_order );
+ friend int atomic_fetch_and_explicit( volatile atomic_int*,
+ int, memory_order );
+ friend int atomic_fetch_or_explicit( volatile atomic_int*,
+ int, memory_order );
+ friend int atomic_fetch_xor_explicit( volatile atomic_int*,
+ int, memory_order );
+
+CPP0X(private:)
+#endif
+ int __f__;
+} atomic_int;
+
+
+typedef struct atomic_uint
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( unsigned int,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned int load( memory_order = memory_order_seq_cst ) volatile;
+ unsigned int exchange( unsigned int,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( unsigned int&, unsigned int,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( unsigned int&, unsigned int,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( unsigned int&, unsigned int,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( unsigned int&, unsigned int,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned int fetch_add( unsigned int,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned int fetch_sub( unsigned int,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned int fetch_and( unsigned int,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned int fetch_or( unsigned int,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned int fetch_xor( unsigned int,
+ memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_uint() = default; )
+ CPP0X( constexpr atomic_uint( unsigned int __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_uint( const atomic_uint& ) = delete; )
+ atomic_uint& operator =( const atomic_uint& ) CPP0X(=delete);
+
+ unsigned int operator =( unsigned int __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ unsigned int operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ unsigned int operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ unsigned int operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ unsigned int operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ unsigned int operator +=( unsigned int __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ unsigned int operator -=( unsigned int __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+
+ unsigned int operator &=( unsigned int __v__ ) volatile
+ { return fetch_and( __v__ ) & __v__; }
+
+ unsigned int operator |=( unsigned int __v__ ) volatile
+ { return fetch_or( __v__ ) | __v__; }
+
+ unsigned int operator ^=( unsigned int __v__ ) volatile
+ { return fetch_xor( __v__ ) ^ __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_uint*, unsigned int,
+ memory_order );
+ friend unsigned int atomic_load_explicit( volatile atomic_uint*,
+ memory_order );
+ friend unsigned int atomic_exchange_explicit( volatile atomic_uint*,
+ unsigned int, memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_uint*,
+ unsigned int*, unsigned int, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_uint*,
+ unsigned int*, unsigned int, memory_order, memory_order );
+ friend unsigned int atomic_fetch_add_explicit( volatile atomic_uint*,
+ unsigned int, memory_order );
+ friend unsigned int atomic_fetch_sub_explicit( volatile atomic_uint*,
+ unsigned int, memory_order );
+ friend unsigned int atomic_fetch_and_explicit( volatile atomic_uint*,
+ unsigned int, memory_order );
+ friend unsigned int atomic_fetch_or_explicit( volatile atomic_uint*,
+ unsigned int, memory_order );
+ friend unsigned int atomic_fetch_xor_explicit( volatile atomic_uint*,
+ unsigned int, memory_order );
+
+CPP0X(private:)
+#endif
+ unsigned int __f__;
+} atomic_uint;
+
+
+typedef struct atomic_long
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( long,
+ memory_order = memory_order_seq_cst ) volatile;
+ long load( memory_order = memory_order_seq_cst ) volatile;
+ long exchange( long,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( long&, long,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( long&, long,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( long&, long,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( long&, long,
+ memory_order = memory_order_seq_cst ) volatile;
+ long fetch_add( long,
+ memory_order = memory_order_seq_cst ) volatile;
+ long fetch_sub( long,
+ memory_order = memory_order_seq_cst ) volatile;
+ long fetch_and( long,
+ memory_order = memory_order_seq_cst ) volatile;
+ long fetch_or( long,
+ memory_order = memory_order_seq_cst ) volatile;
+ long fetch_xor( long,
+ memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_long() = default; )
+ CPP0X( constexpr atomic_long( long __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_long( const atomic_long& ) = delete; )
+ atomic_long& operator =( const atomic_long& ) CPP0X(=delete);
+
+ long operator =( long __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ long operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ long operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ long operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ long operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ long operator +=( long __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ long operator -=( long __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+
+ long operator &=( long __v__ ) volatile
+ { return fetch_and( __v__ ) & __v__; }
+
+ long operator |=( long __v__ ) volatile
+ { return fetch_or( __v__ ) | __v__; }
+
+ long operator ^=( long __v__ ) volatile
+ { return fetch_xor( __v__ ) ^ __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_long*, long,
+ memory_order );
+ friend long atomic_load_explicit( volatile atomic_long*,
+ memory_order );
+ friend long atomic_exchange_explicit( volatile atomic_long*,
+ long, memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_long*,
+ long*, long, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_long*,
+ long*, long, memory_order, memory_order );
+ friend long atomic_fetch_add_explicit( volatile atomic_long*,
+ long, memory_order );
+ friend long atomic_fetch_sub_explicit( volatile atomic_long*,
+ long, memory_order );
+ friend long atomic_fetch_and_explicit( volatile atomic_long*,
+ long, memory_order );
+ friend long atomic_fetch_or_explicit( volatile atomic_long*,
+ long, memory_order );
+ friend long atomic_fetch_xor_explicit( volatile atomic_long*,
+ long, memory_order );
+
+CPP0X(private:)
+#endif
+ long __f__;
+} atomic_long;
+
+
+typedef struct atomic_ulong
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( unsigned long,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned long load( memory_order = memory_order_seq_cst ) volatile;
+ unsigned long exchange( unsigned long,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( unsigned long&, unsigned long,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( unsigned long&, unsigned long,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( unsigned long&, unsigned long,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( unsigned long&, unsigned long,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned long fetch_add( unsigned long,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned long fetch_sub( unsigned long,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned long fetch_and( unsigned long,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned long fetch_or( unsigned long,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned long fetch_xor( unsigned long,
+ memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_ulong() = default; )
+ CPP0X( constexpr atomic_ulong( unsigned long __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_ulong( const atomic_ulong& ) = delete; )
+ atomic_ulong& operator =( const atomic_ulong& ) CPP0X(=delete);
+
+ unsigned long operator =( unsigned long __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ unsigned long operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ unsigned long operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ unsigned long operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ unsigned long operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ unsigned long operator +=( unsigned long __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ unsigned long operator -=( unsigned long __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+
+ unsigned long operator &=( unsigned long __v__ ) volatile
+ { return fetch_and( __v__ ) & __v__; }
+
+ unsigned long operator |=( unsigned long __v__ ) volatile
+ { return fetch_or( __v__ ) | __v__; }
+
+ unsigned long operator ^=( unsigned long __v__ ) volatile
+ { return fetch_xor( __v__ ) ^ __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_ulong*, unsigned long,
+ memory_order );
+ friend unsigned long atomic_load_explicit( volatile atomic_ulong*,
+ memory_order );
+ friend unsigned long atomic_exchange_explicit( volatile atomic_ulong*,
+ unsigned long, memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_ulong*,
+ unsigned long*, unsigned long, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_ulong*,
+ unsigned long*, unsigned long, memory_order, memory_order );
+ friend unsigned long atomic_fetch_add_explicit( volatile atomic_ulong*,
+ unsigned long, memory_order );
+ friend unsigned long atomic_fetch_sub_explicit( volatile atomic_ulong*,
+ unsigned long, memory_order );
+ friend unsigned long atomic_fetch_and_explicit( volatile atomic_ulong*,
+ unsigned long, memory_order );
+ friend unsigned long atomic_fetch_or_explicit( volatile atomic_ulong*,
+ unsigned long, memory_order );
+ friend unsigned long atomic_fetch_xor_explicit( volatile atomic_ulong*,
+ unsigned long, memory_order );
+
+CPP0X(private:)
+#endif
+ unsigned long __f__;
+} atomic_ulong;
+
+
+typedef struct atomic_llong
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ long long load( memory_order = memory_order_seq_cst ) volatile;
+ long long exchange( long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( long long&, long long,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( long long&, long long,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( long long&, long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( long long&, long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ long long fetch_add( long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ long long fetch_sub( long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ long long fetch_and( long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ long long fetch_or( long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ long long fetch_xor( long long,
+ memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_llong() = default; )
+ CPP0X( constexpr atomic_llong( long long __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_llong( const atomic_llong& ) = delete; )
+ atomic_llong& operator =( const atomic_llong& ) CPP0X(=delete);
+
+ long long operator =( long long __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ long long operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ long long operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ long long operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ long long operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ long long operator +=( long long __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ long long operator -=( long long __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+
+ long long operator &=( long long __v__ ) volatile
+ { return fetch_and( __v__ ) & __v__; }
+
+ long long operator |=( long long __v__ ) volatile
+ { return fetch_or( __v__ ) | __v__; }
+
+ long long operator ^=( long long __v__ ) volatile
+ { return fetch_xor( __v__ ) ^ __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_llong*, long long,
+ memory_order );
+ friend long long atomic_load_explicit( volatile atomic_llong*,
+ memory_order );
+ friend long long atomic_exchange_explicit( volatile atomic_llong*,
+ long long, memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_llong*,
+ long long*, long long, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_llong*,
+ long long*, long long, memory_order, memory_order );
+ friend long long atomic_fetch_add_explicit( volatile atomic_llong*,
+ long long, memory_order );
+ friend long long atomic_fetch_sub_explicit( volatile atomic_llong*,
+ long long, memory_order );
+ friend long long atomic_fetch_and_explicit( volatile atomic_llong*,
+ long long, memory_order );
+ friend long long atomic_fetch_or_explicit( volatile atomic_llong*,
+ long long, memory_order );
+ friend long long atomic_fetch_xor_explicit( volatile atomic_llong*,
+ long long, memory_order );
+
+CPP0X(private:)
+#endif
+ long long __f__;
+} atomic_llong;
+
+
+typedef struct atomic_ullong
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( unsigned long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned long long load( memory_order = memory_order_seq_cst ) volatile;
+ unsigned long long exchange( unsigned long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( unsigned long long&, unsigned long long,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( unsigned long long&, unsigned long long,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( unsigned long long&, unsigned long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( unsigned long long&, unsigned long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned long long fetch_add( unsigned long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned long long fetch_sub( unsigned long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned long long fetch_and( unsigned long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned long long fetch_or( unsigned long long,
+ memory_order = memory_order_seq_cst ) volatile;
+ unsigned long long fetch_xor( unsigned long long,
+ memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_ullong() = default; )
+ CPP0X( constexpr atomic_ullong( unsigned long long __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_ullong( const atomic_ullong& ) = delete; )
+ atomic_ullong& operator =( const atomic_ullong& ) CPP0X(=delete);
+
+ unsigned long long operator =( unsigned long long __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ unsigned long long operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ unsigned long long operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ unsigned long long operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ unsigned long long operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ unsigned long long operator +=( unsigned long long __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ unsigned long long operator -=( unsigned long long __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+
+ unsigned long long operator &=( unsigned long long __v__ ) volatile
+ { return fetch_and( __v__ ) & __v__; }
+
+ unsigned long long operator |=( unsigned long long __v__ ) volatile
+ { return fetch_or( __v__ ) | __v__; }
+
+ unsigned long long operator ^=( unsigned long long __v__ ) volatile
+ { return fetch_xor( __v__ ) ^ __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_ullong*, unsigned long long,
+ memory_order );
+ friend unsigned long long atomic_load_explicit( volatile atomic_ullong*,
+ memory_order );
+ friend unsigned long long atomic_exchange_explicit( volatile atomic_ullong*,
+ unsigned long long, memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_ullong*,
+ unsigned long long*, unsigned long long, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_ullong*,
+ unsigned long long*, unsigned long long, memory_order, memory_order );
+ friend unsigned long long atomic_fetch_add_explicit( volatile atomic_ullong*,
+ unsigned long long, memory_order );
+ friend unsigned long long atomic_fetch_sub_explicit( volatile atomic_ullong*,
+ unsigned long long, memory_order );
+ friend unsigned long long atomic_fetch_and_explicit( volatile atomic_ullong*,
+ unsigned long long, memory_order );
+ friend unsigned long long atomic_fetch_or_explicit( volatile atomic_ullong*,
+ unsigned long long, memory_order );
+ friend unsigned long long atomic_fetch_xor_explicit( volatile atomic_ullong*,
+ unsigned long long, memory_order );
+
+CPP0X(private:)
+#endif
+ unsigned long long __f__;
+} atomic_ullong;
+
+
+typedef atomic_schar atomic_int_least8_t;
+typedef atomic_uchar atomic_uint_least8_t;
+typedef atomic_short atomic_int_least16_t;
+typedef atomic_ushort atomic_uint_least16_t;
+typedef atomic_int atomic_int_least32_t;
+typedef atomic_uint atomic_uint_least32_t;
+typedef atomic_llong atomic_int_least64_t;
+typedef atomic_ullong atomic_uint_least64_t;
+
+typedef atomic_schar atomic_int_fast8_t;
+typedef atomic_uchar atomic_uint_fast8_t;
+typedef atomic_short atomic_int_fast16_t;
+typedef atomic_ushort atomic_uint_fast16_t;
+typedef atomic_int atomic_int_fast32_t;
+typedef atomic_uint atomic_uint_fast32_t;
+typedef atomic_llong atomic_int_fast64_t;
+typedef atomic_ullong atomic_uint_fast64_t;
+
+typedef atomic_long atomic_intptr_t;
+typedef atomic_ulong atomic_uintptr_t;
+
+typedef atomic_long atomic_ssize_t;
+typedef atomic_ulong atomic_size_t;
+
+typedef atomic_long atomic_ptrdiff_t;
+
+typedef atomic_llong atomic_intmax_t;
+typedef atomic_ullong atomic_uintmax_t;
+
+
+#ifdef __cplusplus
+
+
+typedef struct atomic_wchar_t
+{
+#ifdef __cplusplus
+ bool is_lock_free() const volatile;
+ void store( wchar_t, memory_order = memory_order_seq_cst ) volatile;
+ wchar_t load( memory_order = memory_order_seq_cst ) volatile;
+ wchar_t exchange( wchar_t,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( wchar_t&, wchar_t,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( wchar_t&, wchar_t,
+ memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( wchar_t&, wchar_t,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( wchar_t&, wchar_t,
+ memory_order = memory_order_seq_cst ) volatile;
+ wchar_t fetch_add( wchar_t,
+ memory_order = memory_order_seq_cst ) volatile;
+ wchar_t fetch_sub( wchar_t,
+ memory_order = memory_order_seq_cst ) volatile;
+ wchar_t fetch_and( wchar_t,
+ memory_order = memory_order_seq_cst ) volatile;
+ wchar_t fetch_or( wchar_t,
+ memory_order = memory_order_seq_cst ) volatile;
+ wchar_t fetch_xor( wchar_t,
+ memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic_wchar_t() = default; )
+ CPP0X( constexpr atomic_wchar_t( wchar_t __v__ ) : __f__( __v__) { } )
+ CPP0X( atomic_wchar_t( const atomic_wchar_t& ) = delete; )
+ atomic_wchar_t& operator =( const atomic_wchar_t& ) CPP0X(=delete);
+
+ wchar_t operator =( wchar_t __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ wchar_t operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ wchar_t operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ wchar_t operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ wchar_t operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ wchar_t operator +=( wchar_t __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ wchar_t operator -=( wchar_t __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+
+ wchar_t operator &=( wchar_t __v__ ) volatile
+ { return fetch_and( __v__ ) & __v__; }
+
+ wchar_t operator |=( wchar_t __v__ ) volatile
+ { return fetch_or( __v__ ) | __v__; }
+
+ wchar_t operator ^=( wchar_t __v__ ) volatile
+ { return fetch_xor( __v__ ) ^ __v__; }
+
+ friend void atomic_store_explicit( volatile atomic_wchar_t*, wchar_t,
+ memory_order );
+ friend wchar_t atomic_load_explicit( volatile atomic_wchar_t*,
+ memory_order );
+ friend wchar_t atomic_exchange_explicit( volatile atomic_wchar_t*,
+ wchar_t, memory_order );
+ friend bool atomic_compare_exchange_weak_explicit( volatile atomic_wchar_t*,
+ wchar_t*, wchar_t, memory_order, memory_order );
+ friend bool atomic_compare_exchange_strong_explicit( volatile atomic_wchar_t*,
+ wchar_t*, wchar_t, memory_order, memory_order );
+ friend wchar_t atomic_fetch_add_explicit( volatile atomic_wchar_t*,
+ wchar_t, memory_order );
+ friend wchar_t atomic_fetch_sub_explicit( volatile atomic_wchar_t*,
+ wchar_t, memory_order );
+ friend wchar_t atomic_fetch_and_explicit( volatile atomic_wchar_t*,
+ wchar_t, memory_order );
+ friend wchar_t atomic_fetch_or_explicit( volatile atomic_wchar_t*,
+ wchar_t, memory_order );
+ friend wchar_t atomic_fetch_xor_explicit( volatile atomic_wchar_t*,
+ wchar_t, memory_order );
+
+CPP0X(private:)
+#endif
+ wchar_t __f__;
+} atomic_wchar_t;
+
+
+#else
+
+typedef atomic_int_least16_t atomic_char16_t;
+typedef atomic_int_least32_t atomic_char32_t;
+typedef atomic_int_least32_t atomic_wchar_t;
+
+#endif
+
+
+#ifdef __cplusplus
+
+template< typename T >
+struct atomic
+{
+#ifdef __cplusplus
+
+ bool is_lock_free() const volatile;
+ void store( T, memory_order = memory_order_seq_cst ) volatile;
+ T load( memory_order = memory_order_seq_cst ) volatile;
+ T exchange( T __v__, memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( T&, T, memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( T&, T, memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( T&, T, memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( T&, T, memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( T __v__ ) : __f__( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ T operator =( T __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+CPP0X(private:)
+#endif
+ T __f__;
+};
+
+#endif
+
+#ifdef __cplusplus
+
+template<typename T> struct atomic< T* > : atomic_address
+{
+ T* load( memory_order = memory_order_seq_cst ) volatile;
+ T* exchange( T*, memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_weak( T*&, T*, memory_order, memory_order ) volatile;
+ bool compare_exchange_strong( T*&, T*, memory_order, memory_order ) volatile;
+ bool compare_exchange_weak( T*&, T*,
+ memory_order = memory_order_seq_cst ) volatile;
+ bool compare_exchange_strong( T*&, T*,
+ memory_order = memory_order_seq_cst ) volatile;
+ T* fetch_add( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
+ T* fetch_sub( ptrdiff_t, memory_order = memory_order_seq_cst ) volatile;
+
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( T __v__ ) : atomic_address( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ T* operator =( T* __v__ ) volatile
+ { store( __v__ ); return __v__; }
+
+ T* operator ++( int ) volatile
+ { return fetch_add( 1 ); }
+
+ T* operator --( int ) volatile
+ { return fetch_sub( 1 ); }
+
+ T* operator ++() volatile
+ { return fetch_add( 1 ) + 1; }
+
+ T* operator --() volatile
+ { return fetch_sub( 1 ) - 1; }
+
+ T* operator +=( T* __v__ ) volatile
+ { return fetch_add( __v__ ) + __v__; }
+
+ T* operator -=( T* __v__ ) volatile
+ { return fetch_sub( __v__ ) - __v__; }
+};
+
+#endif
+
+#ifdef __cplusplus
+
+
+template<> struct atomic< bool > : atomic_bool
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( bool __v__ )
+ : atomic_bool( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ bool operator =( bool __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< void* > : atomic_address
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( void* __v__ )
+ : atomic_address( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ void* operator =( void* __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< char > : atomic_char
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( char __v__ )
+ : atomic_char( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ char operator =( char __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< signed char > : atomic_schar
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( signed char __v__ )
+ : atomic_schar( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ signed char operator =( signed char __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< unsigned char > : atomic_uchar
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( unsigned char __v__ )
+ : atomic_uchar( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ unsigned char operator =( unsigned char __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< short > : atomic_short
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( short __v__ )
+ : atomic_short( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ short operator =( short __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< unsigned short > : atomic_ushort
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( unsigned short __v__ )
+ : atomic_ushort( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ unsigned short operator =( unsigned short __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< int > : atomic_int
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( int __v__ )
+ : atomic_int( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ int operator =( int __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< unsigned int > : atomic_uint
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( unsigned int __v__ )
+ : atomic_uint( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ unsigned int operator =( unsigned int __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< long > : atomic_long
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( long __v__ )
+ : atomic_long( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ long operator =( long __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< unsigned long > : atomic_ulong
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( unsigned long __v__ )
+ : atomic_ulong( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ unsigned long operator =( unsigned long __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< long long > : atomic_llong
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( long long __v__ )
+ : atomic_llong( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ long long operator =( long long __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< unsigned long long > : atomic_ullong
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( unsigned long long __v__ )
+ : atomic_ullong( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ unsigned long long operator =( unsigned long long __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+template<> struct atomic< wchar_t > : atomic_wchar_t
+{
+ CPP0X( atomic() = default; )
+ CPP0X( constexpr explicit atomic( wchar_t __v__ )
+ : atomic_wchar_t( __v__ ) { } )
+ CPP0X( atomic( const atomic& ) = delete; )
+ atomic& operator =( const atomic& ) CPP0X(=delete);
+
+ wchar_t operator =( wchar_t __v__ ) volatile
+ { store( __v__ ); return __v__; }
+};
+
+
+#endif
+
+
+#ifdef __cplusplus
+
+
+inline bool atomic_is_lock_free
+( const volatile atomic_bool* __a__ )
+{ return false; }
+
+inline bool atomic_load_explicit
+( volatile atomic_bool* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline bool atomic_load
+( volatile atomic_bool* __a__ ) { return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_bool* __a__, bool __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_bool* __a__, bool __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_bool* __a__, bool __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_exchange_explicit
+( volatile atomic_bool* __a__, bool __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline bool atomic_exchange
+( volatile atomic_bool* __a__, bool __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_bool* __a__, bool* __e__, bool __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_bool* __a__, bool* __e__, bool __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_bool* __a__, bool* __e__, bool __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_bool* __a__, bool* __e__, bool __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_address* __a__ )
+{ return false; }
+
+inline void* atomic_load_explicit
+( volatile atomic_address* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline void* atomic_load( volatile atomic_address* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_address* __a__, void* __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_address* __a__, void* __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_address* __a__, void* __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline void* atomic_exchange_explicit
+( volatile atomic_address* __a__, void* __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline void* atomic_exchange
+( volatile atomic_address* __a__, void* __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_address* __a__, void** __e__, void* __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_address* __a__, void** __e__, void* __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_address* __a__, void** __e__, void* __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_address* __a__, void** __e__, void* __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_char* __a__ )
+{ return false; }
+
+inline char atomic_load_explicit
+( volatile atomic_char* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline char atomic_load( volatile atomic_char* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_char* __a__, char __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_char* __a__, char __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_char* __a__, char __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline char atomic_exchange_explicit
+( volatile atomic_char* __a__, char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline char atomic_exchange
+( volatile atomic_char* __a__, char __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_char* __a__, char* __e__, char __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_char* __a__, char* __e__, char __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_char* __a__, char* __e__, char __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_char* __a__, char* __e__, char __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_schar* __a__ )
+{ return false; }
+
+inline signed char atomic_load_explicit
+( volatile atomic_schar* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline signed char atomic_load( volatile atomic_schar* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_schar* __a__, signed char __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_schar* __a__, signed char __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline signed char atomic_exchange_explicit
+( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline signed char atomic_exchange
+( volatile atomic_schar* __a__, signed char __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_schar* __a__, signed char* __e__, signed char __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_schar* __a__, signed char* __e__, signed char __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_schar* __a__, signed char* __e__, signed char __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_schar* __a__, signed char* __e__, signed char __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_uchar* __a__ )
+{ return false; }
+
+inline unsigned char atomic_load_explicit
+( volatile atomic_uchar* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline unsigned char atomic_load( volatile atomic_uchar* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_uchar* __a__, unsigned char __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_uchar* __a__, unsigned char __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline unsigned char atomic_exchange_explicit
+( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline unsigned char atomic_exchange
+( volatile atomic_uchar* __a__, unsigned char __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_uchar* __a__, unsigned char* __e__, unsigned char __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_uchar* __a__, unsigned char* __e__, unsigned char __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_uchar* __a__, unsigned char* __e__, unsigned char __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_uchar* __a__, unsigned char* __e__, unsigned char __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_short* __a__ )
+{ return false; }
+
+inline short atomic_load_explicit
+( volatile atomic_short* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline short atomic_load( volatile atomic_short* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_short* __a__, short __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_short* __a__, short __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_short* __a__, short __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline short atomic_exchange_explicit
+( volatile atomic_short* __a__, short __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline short atomic_exchange
+( volatile atomic_short* __a__, short __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_short* __a__, short* __e__, short __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_short* __a__, short* __e__, short __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_short* __a__, short* __e__, short __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_short* __a__, short* __e__, short __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_ushort* __a__ )
+{ return false; }
+
+inline unsigned short atomic_load_explicit
+( volatile atomic_ushort* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline unsigned short atomic_load( volatile atomic_ushort* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_ushort* __a__, unsigned short __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_ushort* __a__, unsigned short __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline unsigned short atomic_exchange_explicit
+( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline unsigned short atomic_exchange
+( volatile atomic_ushort* __a__, unsigned short __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_ushort* __a__, unsigned short* __e__, unsigned short __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_ushort* __a__, unsigned short* __e__, unsigned short __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_ushort* __a__, unsigned short* __e__, unsigned short __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_ushort* __a__, unsigned short* __e__, unsigned short __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_int* __a__ )
+{ return false; }
+
+inline int atomic_load_explicit
+( volatile atomic_int* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline int atomic_load( volatile atomic_int* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_int* __a__, int __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_int* __a__, int __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_int* __a__, int __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline int atomic_exchange_explicit
+( volatile atomic_int* __a__, int __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline int atomic_exchange
+( volatile atomic_int* __a__, int __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_int* __a__, int* __e__, int __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_int* __a__, int* __e__, int __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_int* __a__, int* __e__, int __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_int* __a__, int* __e__, int __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_uint* __a__ )
+{ return false; }
+
+inline unsigned int atomic_load_explicit
+( volatile atomic_uint* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline unsigned int atomic_load( volatile atomic_uint* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_uint* __a__, unsigned int __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_uint* __a__, unsigned int __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline unsigned int atomic_exchange_explicit
+( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline unsigned int atomic_exchange
+( volatile atomic_uint* __a__, unsigned int __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_uint* __a__, unsigned int* __e__, unsigned int __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_uint* __a__, unsigned int* __e__, unsigned int __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_uint* __a__, unsigned int* __e__, unsigned int __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_uint* __a__, unsigned int* __e__, unsigned int __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_long* __a__ )
+{ return false; }
+
+inline long atomic_load_explicit
+( volatile atomic_long* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline long atomic_load( volatile atomic_long* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_long* __a__, long __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_long* __a__, long __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_long* __a__, long __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline long atomic_exchange_explicit
+( volatile atomic_long* __a__, long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline long atomic_exchange
+( volatile atomic_long* __a__, long __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_long* __a__, long* __e__, long __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_long* __a__, long* __e__, long __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_long* __a__, long* __e__, long __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_long* __a__, long* __e__, long __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_ulong* __a__ )
+{ return false; }
+
+inline unsigned long atomic_load_explicit
+( volatile atomic_ulong* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline unsigned long atomic_load( volatile atomic_ulong* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_ulong* __a__, unsigned long __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_ulong* __a__, unsigned long __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline unsigned long atomic_exchange_explicit
+( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline unsigned long atomic_exchange
+( volatile atomic_ulong* __a__, unsigned long __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_ulong* __a__, unsigned long* __e__, unsigned long __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_ulong* __a__, unsigned long* __e__, unsigned long __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_ulong* __a__, unsigned long* __e__, unsigned long __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_ulong* __a__, unsigned long* __e__, unsigned long __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_llong* __a__ )
+{ return false; }
+
+inline long long atomic_load_explicit
+( volatile atomic_llong* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline long long atomic_load( volatile atomic_llong* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_llong* __a__, long long __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_llong* __a__, long long __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline long long atomic_exchange_explicit
+( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline long long atomic_exchange
+( volatile atomic_llong* __a__, long long __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_llong* __a__, long long* __e__, long long __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_llong* __a__, long long* __e__, long long __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_llong* __a__, long long* __e__, long long __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_llong* __a__, long long* __e__, long long __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_ullong* __a__ )
+{ return false; }
+
+inline unsigned long long atomic_load_explicit
+( volatile atomic_ullong* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline unsigned long long atomic_load( volatile atomic_ullong* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_ullong* __a__, unsigned long long __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_ullong* __a__, unsigned long long __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline unsigned long long atomic_exchange_explicit
+( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline unsigned long long atomic_exchange
+( volatile atomic_ullong* __a__, unsigned long long __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_ullong* __a__, unsigned long long* __e__, unsigned long long __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_ullong* __a__, unsigned long long* __e__, unsigned long long __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_ullong* __a__, unsigned long long* __e__, unsigned long long __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_ullong* __a__, unsigned long long* __e__, unsigned long long __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline bool atomic_is_lock_free( const volatile atomic_wchar_t* __a__ )
+{ return false; }
+
+inline wchar_t atomic_load_explicit
+( volatile atomic_wchar_t* __a__, memory_order __x__ )
+{ return _ATOMIC_LOAD_( __a__, __x__ ); }
+
+inline wchar_t atomic_load( volatile atomic_wchar_t* __a__ )
+{ return atomic_load_explicit( __a__, memory_order_seq_cst ); }
+
+inline void atomic_init
+( volatile atomic_wchar_t* __a__, wchar_t __m__ )
+{ _ATOMIC_INIT_( __a__, __m__ ); }
+
+inline void atomic_store_explicit
+( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
+{ _ATOMIC_STORE_( __a__, __m__, __x__ ); }
+
+inline void atomic_store
+( volatile atomic_wchar_t* __a__, wchar_t __m__ )
+{ atomic_store_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline wchar_t atomic_exchange_explicit
+( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, =, __m__, __x__ ); }
+
+inline wchar_t atomic_exchange
+( volatile atomic_wchar_t* __a__, wchar_t __m__ )
+{ return atomic_exchange_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_weak_explicit
+( volatile atomic_wchar_t* __a__, wchar_t* __e__, wchar_t __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_strong_explicit
+( volatile atomic_wchar_t* __a__, wchar_t* __e__, wchar_t __m__,
+ memory_order __x__, memory_order __y__ )
+{ return _ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ ); }
+
+inline bool atomic_compare_exchange_weak
+( volatile atomic_wchar_t* __a__, wchar_t* __e__, wchar_t __m__ )
+{ return atomic_compare_exchange_weak_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+inline bool atomic_compare_exchange_strong
+( volatile atomic_wchar_t* __a__, wchar_t* __e__, wchar_t __m__ )
+{ return atomic_compare_exchange_strong_explicit( __a__, __e__, __m__,
+ memory_order_seq_cst, memory_order_seq_cst ); }
+
+
+inline void* atomic_fetch_add_explicit
+( volatile atomic_address* __a__, ptrdiff_t __m__, memory_order __x__ )
+{
+ void* volatile* __p__ = &((__a__)->__f__);
+ void* __r__ = (void *) model_rmwr_action((void *)__p__, __x__);
+ model_rmw_action((void *)__p__, __x__, (uint64_t) ((char*)(*__p__) + __m__));
+ return __r__; }
+
+inline void* atomic_fetch_add
+( volatile atomic_address* __a__, ptrdiff_t __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline void* atomic_fetch_sub_explicit
+( volatile atomic_address* __a__, ptrdiff_t __m__, memory_order __x__ )
+{
+ void* volatile* __p__ = &((__a__)->__f__);
+ void* __r__ = (void *) model_rmwr_action((void *)__p__, __x__);
+ model_rmw_action((void *)__p__, __x__, (uint64_t)((char*)(*__p__) - __m__));
+ return __r__; }
+
+inline void* atomic_fetch_sub
+( volatile atomic_address* __a__, ptrdiff_t __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+inline char atomic_fetch_add_explicit
+( volatile atomic_char* __a__, char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
+
+inline char atomic_fetch_add
+( volatile atomic_char* __a__, char __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline char atomic_fetch_sub_explicit
+( volatile atomic_char* __a__, char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
+
+inline char atomic_fetch_sub
+( volatile atomic_char* __a__, char __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline char atomic_fetch_and_explicit
+( volatile atomic_char* __a__, char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
+
+inline char atomic_fetch_and
+( volatile atomic_char* __a__, char __m__ )
+{ return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline char atomic_fetch_or_explicit
+( volatile atomic_char* __a__, char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
+
+inline char atomic_fetch_or
+( volatile atomic_char* __a__, char __m__ )
+{ return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline char atomic_fetch_xor_explicit
+( volatile atomic_char* __a__, char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
+
+inline char atomic_fetch_xor
+( volatile atomic_char* __a__, char __m__ )
+{ return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline signed char atomic_fetch_add_explicit
+( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
+
+inline signed char atomic_fetch_add
+( volatile atomic_schar* __a__, signed char __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline signed char atomic_fetch_sub_explicit
+( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
+
+inline signed char atomic_fetch_sub
+( volatile atomic_schar* __a__, signed char __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline signed char atomic_fetch_and_explicit
+( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
+
+inline signed char atomic_fetch_and
+( volatile atomic_schar* __a__, signed char __m__ )
+{ return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline signed char atomic_fetch_or_explicit
+( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
+
+inline signed char atomic_fetch_or
+( volatile atomic_schar* __a__, signed char __m__ )
+{ return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline signed char atomic_fetch_xor_explicit
+( volatile atomic_schar* __a__, signed char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
+
+inline signed char atomic_fetch_xor
+( volatile atomic_schar* __a__, signed char __m__ )
+{ return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned char atomic_fetch_add_explicit
+( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
+
+inline unsigned char atomic_fetch_add
+( volatile atomic_uchar* __a__, unsigned char __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned char atomic_fetch_sub_explicit
+( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
+
+inline unsigned char atomic_fetch_sub
+( volatile atomic_uchar* __a__, unsigned char __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned char atomic_fetch_and_explicit
+( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
+
+inline unsigned char atomic_fetch_and
+( volatile atomic_uchar* __a__, unsigned char __m__ )
+{ return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned char atomic_fetch_or_explicit
+( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
+
+inline unsigned char atomic_fetch_or
+( volatile atomic_uchar* __a__, unsigned char __m__ )
+{ return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned char atomic_fetch_xor_explicit
+( volatile atomic_uchar* __a__, unsigned char __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
+
+inline unsigned char atomic_fetch_xor
+( volatile atomic_uchar* __a__, unsigned char __m__ )
+{ return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline short atomic_fetch_add_explicit
+( volatile atomic_short* __a__, short __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
+
+inline short atomic_fetch_add
+( volatile atomic_short* __a__, short __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline short atomic_fetch_sub_explicit
+( volatile atomic_short* __a__, short __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
+
+inline short atomic_fetch_sub
+( volatile atomic_short* __a__, short __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline short atomic_fetch_and_explicit
+( volatile atomic_short* __a__, short __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
+
+inline short atomic_fetch_and
+( volatile atomic_short* __a__, short __m__ )
+{ return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline short atomic_fetch_or_explicit
+( volatile atomic_short* __a__, short __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
+
+inline short atomic_fetch_or
+( volatile atomic_short* __a__, short __m__ )
+{ return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline short atomic_fetch_xor_explicit
+( volatile atomic_short* __a__, short __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
+
+inline short atomic_fetch_xor
+( volatile atomic_short* __a__, short __m__ )
+{ return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned short atomic_fetch_add_explicit
+( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
+
+inline unsigned short atomic_fetch_add
+( volatile atomic_ushort* __a__, unsigned short __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned short atomic_fetch_sub_explicit
+( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
+
+inline unsigned short atomic_fetch_sub
+( volatile atomic_ushort* __a__, unsigned short __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned short atomic_fetch_and_explicit
+( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
+
+inline unsigned short atomic_fetch_and
+( volatile atomic_ushort* __a__, unsigned short __m__ )
+{ return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned short atomic_fetch_or_explicit
+( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
+
+inline unsigned short atomic_fetch_or
+( volatile atomic_ushort* __a__, unsigned short __m__ )
+{ return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned short atomic_fetch_xor_explicit
+( volatile atomic_ushort* __a__, unsigned short __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
+
+inline unsigned short atomic_fetch_xor
+( volatile atomic_ushort* __a__, unsigned short __m__ )
+{ return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline int atomic_fetch_add_explicit
+( volatile atomic_int* __a__, int __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
+
+inline int atomic_fetch_add
+( volatile atomic_int* __a__, int __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline int atomic_fetch_sub_explicit
+( volatile atomic_int* __a__, int __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
+
+inline int atomic_fetch_sub
+( volatile atomic_int* __a__, int __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline int atomic_fetch_and_explicit
+( volatile atomic_int* __a__, int __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
+
+inline int atomic_fetch_and
+( volatile atomic_int* __a__, int __m__ )
+{ return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline int atomic_fetch_or_explicit
+( volatile atomic_int* __a__, int __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
+
+inline int atomic_fetch_or
+( volatile atomic_int* __a__, int __m__ )
+{ return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline int atomic_fetch_xor_explicit
+( volatile atomic_int* __a__, int __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
+
+inline int atomic_fetch_xor
+( volatile atomic_int* __a__, int __m__ )
+{ return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned int atomic_fetch_add_explicit
+( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
+
+inline unsigned int atomic_fetch_add
+( volatile atomic_uint* __a__, unsigned int __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned int atomic_fetch_sub_explicit
+( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
+
+inline unsigned int atomic_fetch_sub
+( volatile atomic_uint* __a__, unsigned int __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned int atomic_fetch_and_explicit
+( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
+
+inline unsigned int atomic_fetch_and
+( volatile atomic_uint* __a__, unsigned int __m__ )
+{ return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned int atomic_fetch_or_explicit
+( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
+
+inline unsigned int atomic_fetch_or
+( volatile atomic_uint* __a__, unsigned int __m__ )
+{ return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned int atomic_fetch_xor_explicit
+( volatile atomic_uint* __a__, unsigned int __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
+
+inline unsigned int atomic_fetch_xor
+( volatile atomic_uint* __a__, unsigned int __m__ )
+{ return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline long atomic_fetch_add_explicit
+( volatile atomic_long* __a__, long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
+
+inline long atomic_fetch_add
+( volatile atomic_long* __a__, long __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline long atomic_fetch_sub_explicit
+( volatile atomic_long* __a__, long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
+
+inline long atomic_fetch_sub
+( volatile atomic_long* __a__, long __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline long atomic_fetch_and_explicit
+( volatile atomic_long* __a__, long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
+
+inline long atomic_fetch_and
+( volatile atomic_long* __a__, long __m__ )
+{ return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline long atomic_fetch_or_explicit
+( volatile atomic_long* __a__, long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
+
+inline long atomic_fetch_or
+( volatile atomic_long* __a__, long __m__ )
+{ return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline long atomic_fetch_xor_explicit
+( volatile atomic_long* __a__, long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
+
+inline long atomic_fetch_xor
+( volatile atomic_long* __a__, long __m__ )
+{ return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned long atomic_fetch_add_explicit
+( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
+
+inline unsigned long atomic_fetch_add
+( volatile atomic_ulong* __a__, unsigned long __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned long atomic_fetch_sub_explicit
+( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
+
+inline unsigned long atomic_fetch_sub
+( volatile atomic_ulong* __a__, unsigned long __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned long atomic_fetch_and_explicit
+( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
+
+inline unsigned long atomic_fetch_and
+( volatile atomic_ulong* __a__, unsigned long __m__ )
+{ return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned long atomic_fetch_or_explicit
+( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
+
+inline unsigned long atomic_fetch_or
+( volatile atomic_ulong* __a__, unsigned long __m__ )
+{ return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned long atomic_fetch_xor_explicit
+( volatile atomic_ulong* __a__, unsigned long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
+
+inline unsigned long atomic_fetch_xor
+( volatile atomic_ulong* __a__, unsigned long __m__ )
+{ return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline long long atomic_fetch_add_explicit
+( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
+
+inline long long atomic_fetch_add
+( volatile atomic_llong* __a__, long long __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline long long atomic_fetch_sub_explicit
+( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
+
+inline long long atomic_fetch_sub
+( volatile atomic_llong* __a__, long long __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline long long atomic_fetch_and_explicit
+( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
+
+inline long long atomic_fetch_and
+( volatile atomic_llong* __a__, long long __m__ )
+{ return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline long long atomic_fetch_or_explicit
+( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
+
+inline long long atomic_fetch_or
+( volatile atomic_llong* __a__, long long __m__ )
+{ return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline long long atomic_fetch_xor_explicit
+( volatile atomic_llong* __a__, long long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
+
+inline long long atomic_fetch_xor
+( volatile atomic_llong* __a__, long long __m__ )
+{ return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned long long atomic_fetch_add_explicit
+( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
+
+inline unsigned long long atomic_fetch_add
+( volatile atomic_ullong* __a__, unsigned long long __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned long long atomic_fetch_sub_explicit
+( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
+
+inline unsigned long long atomic_fetch_sub
+( volatile atomic_ullong* __a__, unsigned long long __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned long long atomic_fetch_and_explicit
+( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
+
+inline unsigned long long atomic_fetch_and
+( volatile atomic_ullong* __a__, unsigned long long __m__ )
+{ return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned long long atomic_fetch_or_explicit
+( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
+
+inline unsigned long long atomic_fetch_or
+( volatile atomic_ullong* __a__, unsigned long long __m__ )
+{ return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline unsigned long long atomic_fetch_xor_explicit
+( volatile atomic_ullong* __a__, unsigned long long __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
+
+inline unsigned long long atomic_fetch_xor
+( volatile atomic_ullong* __a__, unsigned long long __m__ )
+{ return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline wchar_t atomic_fetch_add_explicit
+( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, +=, __m__, __x__ ); }
+
+inline wchar_t atomic_fetch_add
+( volatile atomic_wchar_t* __a__, wchar_t __m__ )
+{ return atomic_fetch_add_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline wchar_t atomic_fetch_sub_explicit
+( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, -=, __m__, __x__ ); }
+
+inline wchar_t atomic_fetch_sub
+( volatile atomic_wchar_t* __a__, wchar_t __m__ )
+{ return atomic_fetch_sub_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline wchar_t atomic_fetch_and_explicit
+( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, &=, __m__, __x__ ); }
+
+inline wchar_t atomic_fetch_and
+( volatile atomic_wchar_t* __a__, wchar_t __m__ )
+{ return atomic_fetch_and_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline wchar_t atomic_fetch_or_explicit
+( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, |=, __m__, __x__ ); }
+
+inline wchar_t atomic_fetch_or
+( volatile atomic_wchar_t* __a__, wchar_t __m__ )
+{ return atomic_fetch_or_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+inline wchar_t atomic_fetch_xor_explicit
+( volatile atomic_wchar_t* __a__, wchar_t __m__, memory_order __x__ )
+{ return _ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ ); }
+
+inline wchar_t atomic_fetch_xor
+( volatile atomic_wchar_t* __a__, wchar_t __m__ )
+{ return atomic_fetch_xor_explicit( __a__, __m__, memory_order_seq_cst ); }
+
+
+#else
+
+
+#define atomic_is_lock_free( __a__ ) \
+false
+
+#define atomic_load( __a__ ) \
+_ATOMIC_LOAD_( __a__, memory_order_seq_cst )
+
+#define atomic_load_explicit( __a__, __x__ ) \
+_ATOMIC_LOAD_( __a__, __x__ )
+
+#define atomic_init( __a__, __m__ ) \
+_ATOMIC_INIT_( __a__, __m__ )
+
+#define atomic_store( __a__, __m__ ) \
+_ATOMIC_STORE_( __a__, __m__, memory_order_seq_cst )
+
+#define atomic_store_explicit( __a__, __m__, __x__ ) \
+_ATOMIC_STORE_( __a__, __m__, __x__ )
+
+#define atomic_exchange( __a__, __m__ ) \
+_ATOMIC_MODIFY_( __a__, =, __m__, memory_order_seq_cst )
+
+#define atomic_exchange_explicit( __a__, __m__, __x__ ) \
+_ATOMIC_MODIFY_( __a__, =, __m__, __x__ )
+
+#define atomic_compare_exchange_weak( __a__, __e__, __m__ ) \
+_ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, memory_order_seq_cst )
+
+#define atomic_compare_exchange_strong( __a__, __e__, __m__ ) \
+_ATOMIC_CMPSWP_( __a__, __e__, __m__, memory_order_seq_cst )
+
+#define atomic_compare_exchange_weak_explicit( __a__, __e__, __m__, __x__, __y__ ) \
+_ATOMIC_CMPSWP_WEAK_( __a__, __e__, __m__, __x__ )
+
+#define atomic_compare_exchange_strong_explicit( __a__, __e__, __m__, __x__, __y__ ) \
+_ATOMIC_CMPSWP_( __a__, __e__, __m__, __x__ )
+
+
+#define atomic_fetch_add_explicit( __a__, __m__, __x__ ) \
+_ATOMIC_MODIFY_( __a__, +=, __m__, __x__ )
+
+#define atomic_fetch_add( __a__, __m__ ) \
+_ATOMIC_MODIFY_( __a__, +=, __m__, memory_order_seq_cst )
+
+
+#define atomic_fetch_sub_explicit( __a__, __m__, __x__ ) \
+_ATOMIC_MODIFY_( __a__, -=, __m__, __x__ )
+
+#define atomic_fetch_sub( __a__, __m__ ) \
+_ATOMIC_MODIFY_( __a__, -=, __m__, memory_order_seq_cst )
+
+
+#define atomic_fetch_and_explicit( __a__, __m__, __x__ ) \
+_ATOMIC_MODIFY_( __a__, &=, __m__, __x__ )
+
+#define atomic_fetch_and( __a__, __m__ ) \
+_ATOMIC_MODIFY_( __a__, &=, __m__, memory_order_seq_cst )
+
+
+#define atomic_fetch_or_explicit( __a__, __m__, __x__ ) \
+_ATOMIC_MODIFY_( __a__, |=, __m__, __x__ )
+
+#define atomic_fetch_or( __a__, __m__ ) \
+_ATOMIC_MODIFY_( __a__, |=, __m__, memory_order_seq_cst )
+
+
+#define atomic_fetch_xor_explicit( __a__, __m__, __x__ ) \
+_ATOMIC_MODIFY_( __a__, ^=, __m__, __x__ )
+
+#define atomic_fetch_xor( __a__, __m__ ) \
+_ATOMIC_MODIFY_( __a__, ^=, __m__, memory_order_seq_cst )
+
+
+#endif
+
+
+#ifdef __cplusplus
+
+
+inline bool atomic_bool::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_bool::store
+( bool __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_bool::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline bool atomic_bool::exchange
+( bool __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_bool::compare_exchange_weak
+( bool& __e__, bool __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_bool::compare_exchange_strong
+( bool& __e__, bool __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_bool::compare_exchange_weak
+( bool& __e__, bool __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_bool::compare_exchange_strong
+( bool& __e__, bool __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_address::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_address::store
+( void* __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline void* atomic_address::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline void* atomic_address::exchange
+( void* __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_address::compare_exchange_weak
+( void*& __e__, void* __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_address::compare_exchange_strong
+( void*& __e__, void* __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_address::compare_exchange_weak
+( void*& __e__, void* __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_address::compare_exchange_strong
+( void*& __e__, void* __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_char::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_char::store
+( char __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline char atomic_char::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline char atomic_char::exchange
+( char __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_char::compare_exchange_weak
+( char& __e__, char __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_char::compare_exchange_strong
+( char& __e__, char __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_char::compare_exchange_weak
+( char& __e__, char __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_char::compare_exchange_strong
+( char& __e__, char __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_schar::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_schar::store
+( signed char __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline signed char atomic_schar::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline signed char atomic_schar::exchange
+( signed char __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_schar::compare_exchange_weak
+( signed char& __e__, signed char __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_schar::compare_exchange_strong
+( signed char& __e__, signed char __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_schar::compare_exchange_weak
+( signed char& __e__, signed char __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_schar::compare_exchange_strong
+( signed char& __e__, signed char __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_uchar::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_uchar::store
+( unsigned char __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline unsigned char atomic_uchar::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline unsigned char atomic_uchar::exchange
+( unsigned char __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_uchar::compare_exchange_weak
+( unsigned char& __e__, unsigned char __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_uchar::compare_exchange_strong
+( unsigned char& __e__, unsigned char __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_uchar::compare_exchange_weak
+( unsigned char& __e__, unsigned char __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_uchar::compare_exchange_strong
+( unsigned char& __e__, unsigned char __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_short::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_short::store
+( short __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline short atomic_short::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline short atomic_short::exchange
+( short __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_short::compare_exchange_weak
+( short& __e__, short __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_short::compare_exchange_strong
+( short& __e__, short __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_short::compare_exchange_weak
+( short& __e__, short __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_short::compare_exchange_strong
+( short& __e__, short __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_ushort::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_ushort::store
+( unsigned short __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline unsigned short atomic_ushort::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline unsigned short atomic_ushort::exchange
+( unsigned short __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_ushort::compare_exchange_weak
+( unsigned short& __e__, unsigned short __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_ushort::compare_exchange_strong
+( unsigned short& __e__, unsigned short __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_ushort::compare_exchange_weak
+( unsigned short& __e__, unsigned short __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_ushort::compare_exchange_strong
+( unsigned short& __e__, unsigned short __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_int::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_int::store
+( int __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline int atomic_int::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline int atomic_int::exchange
+( int __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_int::compare_exchange_weak
+( int& __e__, int __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_int::compare_exchange_strong
+( int& __e__, int __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_int::compare_exchange_weak
+( int& __e__, int __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_int::compare_exchange_strong
+( int& __e__, int __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_uint::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_uint::store
+( unsigned int __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline unsigned int atomic_uint::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline unsigned int atomic_uint::exchange
+( unsigned int __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_uint::compare_exchange_weak
+( unsigned int& __e__, unsigned int __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_uint::compare_exchange_strong
+( unsigned int& __e__, unsigned int __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_uint::compare_exchange_weak
+( unsigned int& __e__, unsigned int __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_uint::compare_exchange_strong
+( unsigned int& __e__, unsigned int __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_long::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_long::store
+( long __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline long atomic_long::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline long atomic_long::exchange
+( long __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_long::compare_exchange_weak
+( long& __e__, long __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_long::compare_exchange_strong
+( long& __e__, long __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_long::compare_exchange_weak
+( long& __e__, long __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_long::compare_exchange_strong
+( long& __e__, long __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_ulong::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_ulong::store
+( unsigned long __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline unsigned long atomic_ulong::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline unsigned long atomic_ulong::exchange
+( unsigned long __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_ulong::compare_exchange_weak
+( unsigned long& __e__, unsigned long __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_ulong::compare_exchange_strong
+( unsigned long& __e__, unsigned long __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_ulong::compare_exchange_weak
+( unsigned long& __e__, unsigned long __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_ulong::compare_exchange_strong
+( unsigned long& __e__, unsigned long __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_llong::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_llong::store
+( long long __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline long long atomic_llong::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline long long atomic_llong::exchange
+( long long __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_llong::compare_exchange_weak
+( long long& __e__, long long __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_llong::compare_exchange_strong
+( long long& __e__, long long __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_llong::compare_exchange_weak
+( long long& __e__, long long __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_llong::compare_exchange_strong
+( long long& __e__, long long __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_ullong::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_ullong::store
+( unsigned long long __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline unsigned long long atomic_ullong::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline unsigned long long atomic_ullong::exchange
+( unsigned long long __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_ullong::compare_exchange_weak
+( unsigned long long& __e__, unsigned long long __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_ullong::compare_exchange_strong
+( unsigned long long& __e__, unsigned long long __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_ullong::compare_exchange_weak
+( unsigned long long& __e__, unsigned long long __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_ullong::compare_exchange_strong
+( unsigned long long& __e__, unsigned long long __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline bool atomic_wchar_t::is_lock_free() const volatile
+{ return false; }
+
+inline void atomic_wchar_t::store
+( wchar_t __m__, memory_order __x__ ) volatile
+{ atomic_store_explicit( this, __m__, __x__ ); }
+
+inline wchar_t atomic_wchar_t::load
+( memory_order __x__ ) volatile
+{ return atomic_load_explicit( this, __x__ ); }
+
+inline wchar_t atomic_wchar_t::exchange
+( wchar_t __m__, memory_order __x__ ) volatile
+{ return atomic_exchange_explicit( this, __m__, __x__ ); }
+
+inline bool atomic_wchar_t::compare_exchange_weak
+( wchar_t& __e__, wchar_t __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_wchar_t::compare_exchange_strong
+( wchar_t& __e__, wchar_t __m__,
+ memory_order __x__, memory_order __y__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__, __y__ ); }
+
+inline bool atomic_wchar_t::compare_exchange_weak
+( wchar_t& __e__, wchar_t __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_weak_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+inline bool atomic_wchar_t::compare_exchange_strong
+( wchar_t& __e__, wchar_t __m__, memory_order __x__ ) volatile
+{ return atomic_compare_exchange_strong_explicit( this, &__e__, __m__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+template< typename T >
+inline bool atomic<T>::is_lock_free() const volatile
+{ return false; }
+
+template< typename T >
+inline void atomic<T>::store( T __v__, memory_order __x__ ) volatile
+{ _ATOMIC_STORE_( this, __v__, __x__ ); }
+
+template< typename T >
+inline T atomic<T>::load( memory_order __x__ ) volatile
+{ return _ATOMIC_LOAD_( this, __x__ ); }
+
+template< typename T >
+inline T atomic<T>::exchange( T __v__, memory_order __x__ ) volatile
+{ return _ATOMIC_MODIFY_( this, =, __v__, __x__ ); }
+
+template< typename T >
+inline bool atomic<T>::compare_exchange_weak
+( T& __r__, T __v__, memory_order __x__, memory_order __y__ ) volatile
+{ return _ATOMIC_CMPSWP_WEAK_( this, &__r__, __v__, __x__ ); }
+
+template< typename T >
+inline bool atomic<T>::compare_exchange_strong
+( T& __r__, T __v__, memory_order __x__, memory_order __y__ ) volatile
+{ return _ATOMIC_CMPSWP_( this, &__r__, __v__, __x__ ); }
+
+template< typename T >
+inline bool atomic<T>::compare_exchange_weak
+( T& __r__, T __v__, memory_order __x__ ) volatile
+{ return compare_exchange_weak( __r__, __v__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+template< typename T >
+inline bool atomic<T>::compare_exchange_strong
+( T& __r__, T __v__, memory_order __x__ ) volatile
+{ return compare_exchange_strong( __r__, __v__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+
+inline void* atomic_address::fetch_add
+( ptrdiff_t __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+inline void* atomic_address::fetch_sub
+( ptrdiff_t __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline char atomic_char::fetch_add
+( char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+
+inline char atomic_char::fetch_sub
+( char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline char atomic_char::fetch_and
+( char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_and_explicit( this, __m__, __x__ ); }
+
+
+inline char atomic_char::fetch_or
+( char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_or_explicit( this, __m__, __x__ ); }
+
+
+inline char atomic_char::fetch_xor
+( char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
+
+
+inline signed char atomic_schar::fetch_add
+( signed char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+
+inline signed char atomic_schar::fetch_sub
+( signed char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline signed char atomic_schar::fetch_and
+( signed char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_and_explicit( this, __m__, __x__ ); }
+
+
+inline signed char atomic_schar::fetch_or
+( signed char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_or_explicit( this, __m__, __x__ ); }
+
+
+inline signed char atomic_schar::fetch_xor
+( signed char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned char atomic_uchar::fetch_add
+( unsigned char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned char atomic_uchar::fetch_sub
+( unsigned char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned char atomic_uchar::fetch_and
+( unsigned char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_and_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned char atomic_uchar::fetch_or
+( unsigned char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_or_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned char atomic_uchar::fetch_xor
+( unsigned char __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
+
+
+inline short atomic_short::fetch_add
+( short __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+
+inline short atomic_short::fetch_sub
+( short __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline short atomic_short::fetch_and
+( short __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_and_explicit( this, __m__, __x__ ); }
+
+
+inline short atomic_short::fetch_or
+( short __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_or_explicit( this, __m__, __x__ ); }
+
+
+inline short atomic_short::fetch_xor
+( short __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned short atomic_ushort::fetch_add
+( unsigned short __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned short atomic_ushort::fetch_sub
+( unsigned short __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned short atomic_ushort::fetch_and
+( unsigned short __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_and_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned short atomic_ushort::fetch_or
+( unsigned short __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_or_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned short atomic_ushort::fetch_xor
+( unsigned short __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
+
+
+inline int atomic_int::fetch_add
+( int __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+
+inline int atomic_int::fetch_sub
+( int __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline int atomic_int::fetch_and
+( int __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_and_explicit( this, __m__, __x__ ); }
+
+
+inline int atomic_int::fetch_or
+( int __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_or_explicit( this, __m__, __x__ ); }
+
+
+inline int atomic_int::fetch_xor
+( int __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned int atomic_uint::fetch_add
+( unsigned int __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned int atomic_uint::fetch_sub
+( unsigned int __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned int atomic_uint::fetch_and
+( unsigned int __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_and_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned int atomic_uint::fetch_or
+( unsigned int __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_or_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned int atomic_uint::fetch_xor
+( unsigned int __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
+
+
+inline long atomic_long::fetch_add
+( long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+
+inline long atomic_long::fetch_sub
+( long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline long atomic_long::fetch_and
+( long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_and_explicit( this, __m__, __x__ ); }
+
+
+inline long atomic_long::fetch_or
+( long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_or_explicit( this, __m__, __x__ ); }
+
+
+inline long atomic_long::fetch_xor
+( long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned long atomic_ulong::fetch_add
+( unsigned long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned long atomic_ulong::fetch_sub
+( unsigned long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned long atomic_ulong::fetch_and
+( unsigned long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_and_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned long atomic_ulong::fetch_or
+( unsigned long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_or_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned long atomic_ulong::fetch_xor
+( unsigned long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
+
+
+inline long long atomic_llong::fetch_add
+( long long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+
+inline long long atomic_llong::fetch_sub
+( long long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline long long atomic_llong::fetch_and
+( long long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_and_explicit( this, __m__, __x__ ); }
+
+
+inline long long atomic_llong::fetch_or
+( long long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_or_explicit( this, __m__, __x__ ); }
+
+
+inline long long atomic_llong::fetch_xor
+( long long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned long long atomic_ullong::fetch_add
+( unsigned long long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned long long atomic_ullong::fetch_sub
+( unsigned long long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned long long atomic_ullong::fetch_and
+( unsigned long long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_and_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned long long atomic_ullong::fetch_or
+( unsigned long long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_or_explicit( this, __m__, __x__ ); }
+
+
+inline unsigned long long atomic_ullong::fetch_xor
+( unsigned long long __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
+
+
+inline wchar_t atomic_wchar_t::fetch_add
+( wchar_t __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, __m__, __x__ ); }
+
+
+inline wchar_t atomic_wchar_t::fetch_sub
+( wchar_t __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, __m__, __x__ ); }
+
+
+inline wchar_t atomic_wchar_t::fetch_and
+( wchar_t __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_and_explicit( this, __m__, __x__ ); }
+
+
+inline wchar_t atomic_wchar_t::fetch_or
+( wchar_t __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_or_explicit( this, __m__, __x__ ); }
+
+
+inline wchar_t atomic_wchar_t::fetch_xor
+( wchar_t __m__, memory_order __x__ ) volatile
+{ return atomic_fetch_xor_explicit( this, __m__, __x__ ); }
+
+
+template< typename T >
+T* atomic<T*>::load( memory_order __x__ ) volatile
+{ return static_cast<T*>( atomic_address::load( __x__ ) ); }
+
+template< typename T >
+T* atomic<T*>::exchange( T* __v__, memory_order __x__ ) volatile
+{ return static_cast<T*>( atomic_address::exchange( __v__, __x__ ) ); }
+
+template< typename T >
+bool atomic<T*>::compare_exchange_weak
+( T*& __r__, T* __v__, memory_order __x__, memory_order __y__) volatile
+{ return atomic_address::compare_exchange_weak( *reinterpret_cast<void**>( &__r__ ),
+ static_cast<void*>( __v__ ), __x__, __y__ ); }
+//{ return _ATOMIC_CMPSWP_WEAK_( this, &__r__, __v__, __x__ ); }
+
+template< typename T >
+bool atomic<T*>::compare_exchange_strong
+( T*& __r__, T* __v__, memory_order __x__, memory_order __y__) volatile
+{ return atomic_address::compare_exchange_strong( *reinterpret_cast<void**>( &__r__ ),
+ static_cast<void*>( __v__ ), __x__, __y__ ); }
+//{ return _ATOMIC_CMPSWP_( this, &__r__, __v__, __x__ ); }
+
+template< typename T >
+bool atomic<T*>::compare_exchange_weak
+( T*& __r__, T* __v__, memory_order __x__ ) volatile
+{ return compare_exchange_weak( __r__, __v__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+template< typename T >
+bool atomic<T*>::compare_exchange_strong
+( T*& __r__, T* __v__, memory_order __x__ ) volatile
+{ return compare_exchange_strong( __r__, __v__, __x__,
+ __x__ == memory_order_acq_rel ? memory_order_acquire :
+ __x__ == memory_order_release ? memory_order_relaxed : __x__ ); }
+
+template< typename T >
+T* atomic<T*>::fetch_add( ptrdiff_t __v__, memory_order __x__ ) volatile
+{ return atomic_fetch_add_explicit( this, sizeof(T) * __v__, __x__ ); }
+
+template< typename T >
+T* atomic<T*>::fetch_sub( ptrdiff_t __v__, memory_order __x__ ) volatile
+{ return atomic_fetch_sub_explicit( this, sizeof(T) * __v__, __x__ ); }
+
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+static inline void atomic_thread_fence(memory_order order)
+{ _ATOMIC_FENCE_(order); }
+
+/** @todo Do we want to try to support a user's signal-handler? */
+static inline void atomic_signal_fence(memory_order order)
+{ /* No-op? */ }
+#ifdef __cplusplus
+}
+#endif
+
+
+#ifdef __cplusplus
+} // namespace std
+#endif
+
+#endif /* __IMPATOMIC_H__ */
--- /dev/null
+/** @file librace.h
+ * @brief Interface to check normal memory operations for data races.
+ */
+
+#ifndef __LIBRACE_H__
+#define __LIBRACE_H__
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ void store_8(void *addr, uint8_t val);
+ void store_16(void *addr, uint16_t val);
+ void store_32(void *addr, uint32_t val);
+ void store_64(void *addr, uint64_t val);
+
+ uint8_t load_8(const void *addr);
+ uint16_t load_16(const void *addr);
+ uint32_t load_32(const void *addr);
+ uint64_t load_64(const void *addr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __LIBRACE_H__ */
--- /dev/null
+/**
+ * @file memoryorder.h
+ * @brief C11/C++11 atomic memory order listings
+ */
+
+#ifndef MEMORYORDER_H
+#define MEMORYORDER_H
+#ifdef __cplusplus
+#include <cstddef>
+namespace std {
+#else
+#include <stddef.h>
+#endif
+
+
+typedef enum memory_order {
+ memory_order_relaxed, memory_order_acquire, memory_order_release,
+ memory_order_acq_rel, memory_order_seq_cst
+} memory_order;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif
--- /dev/null
+#ifndef __MODEL_ASSERT_H__
+#define __MODEL_ASSERT_H__
+
+#if __cplusplus
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+void model_assert(bool expr, const char *file, int line);
+#define MODEL_ASSERT(expr) model_assert((expr), __FILE__, __LINE__)
+
+#if __cplusplus
+}
+#endif
+
+#endif /* __MODEL_ASSERT_H__ */
--- /dev/null
+/**
+ * @file modeltypes.h
+ * @brief Common typedefs for the model-checker
+ */
+
+#ifndef __MODELTYPES_H__
+#define __MODELTYPES_H__
+
+/**
+ * @brief Represents a unique ID for a Thread
+ *
+ * The space of unique IDs may need to become a non-compact
+ * or non-zero-indexed set of integers (or even some other
+ * type). So this typedef is used to help identify which is
+ * which, where a simple 'int' is meant to be a compact,
+ * zero-indexed set and a 'thread_id_t' may be another type
+ * entirely.
+ *
+ * @see id_to_int
+ * @see int_to_id
+ */
+typedef int thread_id_t;
+
+#define THREAD_ID_T_NONE -1
+
+typedef unsigned int modelclock_t;
+
+#endif /* __MODELTYPES_H__ */
--- /dev/null
+/**
+ * @file mutex
+ * @brief C++11 mutex interface header
+ */
+
+#ifndef __CXX_MUTEX__
+#define __CXX_MUTEX__
+
+#include "modeltypes.h"
+
+namespace std {
+ struct mutex_state {
+ void *locked; /* Thread holding the lock */
+ thread_id_t alloc_tid;
+ modelclock_t alloc_clock;
+ };
+
+ class mutex {
+ public:
+ mutex();
+ ~mutex() {}
+ void lock();
+ bool try_lock();
+ void unlock();
+ struct mutex_state * get_state() {return &state;}
+
+ private:
+ struct mutex_state state;
+ };
+}
+#endif /* __CXX_MUTEX__ */
--- /dev/null
+/**
+ * @file stdatomic.h
+ * @brief C11 atomic interface header
+ */
+
+#ifndef __STDATOMIC_H__
+#define __STDATOMIC_H__
+
+#include "impatomic.h"
+
+#ifdef __cplusplus
+
+
+using std::atomic_flag;
+
+
+using std::atomic_bool;
+
+
+using std::atomic_address;
+
+
+using std::atomic_char;
+
+
+using std::atomic_schar;
+
+
+using std::atomic_uchar;
+
+
+using std::atomic_short;
+
+
+using std::atomic_ushort;
+
+
+using std::atomic_int;
+
+
+using std::atomic_uint;
+
+
+using std::atomic_long;
+
+
+using std::atomic_ulong;
+
+
+using std::atomic_llong;
+
+
+using std::atomic_ullong;
+
+
+using std::atomic_wchar_t;
+
+
+using std::atomic;
+using std::memory_order;
+using std::memory_order_relaxed;
+using std::memory_order_acquire;
+using std::memory_order_release;
+using std::memory_order_acq_rel;
+using std::memory_order_seq_cst;
+
+using std::atomic_thread_fence;
+using std::atomic_signal_fence;
+
+#endif /* __cplusplus */
+
+#endif /* __STDATOMIC_H__ */
--- /dev/null
+/** @file threads.h
+ * @brief C11 Thread Library Functionality
+ */
+
+#ifndef __THREADS_H__
+#define __THREADS_H__
+
+/* Forward declaration */
+#ifdef __cplusplus
+typedef class Thread *__thread_identifier;
+#else
+/* For C, we just need an opaque pointer */
+typedef void *__thread_identifier;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ typedef void (*thrd_start_t)(void *);
+
+ typedef struct {
+ __thread_identifier priv;
+ } thrd_t;
+
+ int thrd_create(thrd_t *t, thrd_start_t start_routine, void *arg);
+ int thrd_join(thrd_t);
+ void thrd_yield(void);
+ thrd_t thrd_current(void);
+
+ int user_main(int, char**);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __THREADS_H__ */
--- /dev/null
+#include <cdsannotate.h>
+#include "common.h"
+#include "action.h"
+#include "model.h"
+
+/** Pass in an annotation that a trace analysis will use. The
+ * analysis type is a unique number that specifies which trace
+ * analysis needs the annotation. The reference is to a data
+ * structure that the trace understands. */
+
+void cdsannotate(uint64_t analysistype, void *annotation) {
+ /* seq_cst is just a 'don't care' parameter */
+ model->switch_to_master(new ModelAction(ATOMIC_ANNOTATION, std::memory_order_seq_cst, annotation, analysistype));
+}
--- /dev/null
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+
+#include "librace.h"
+#include "common.h"
+#include "datarace.h"
+#include "model.h"
+#include "threads-model.h"
+
+void store_8(void *addr, uint8_t val)
+{
+ DEBUG("addr = %p, val = %" PRIu8 "\n", addr, val);
+ thread_id_t tid = thread_current()->get_id();
+ raceCheckWrite(tid, addr);
+ (*(uint8_t *)addr) = val;
+}
+
+void store_16(void *addr, uint16_t val)
+{
+ DEBUG("addr = %p, val = %" PRIu16 "\n", addr, val);
+ thread_id_t tid = thread_current()->get_id();
+ raceCheckWrite(tid, addr);
+ raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 1));
+ (*(uint16_t *)addr) = val;
+}
+
+void store_32(void *addr, uint32_t val)
+{
+ DEBUG("addr = %p, val = %" PRIu32 "\n", addr, val);
+ thread_id_t tid = thread_current()->get_id();
+ raceCheckWrite(tid, addr);
+ raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 1));
+ raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 2));
+ raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 3));
+ (*(uint32_t *)addr) = val;
+}
+
+void store_64(void *addr, uint64_t val)
+{
+ DEBUG("addr = %p, val = %" PRIu64 "\n", addr, val);
+ thread_id_t tid = thread_current()->get_id();
+ raceCheckWrite(tid, addr);
+ raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 1));
+ raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 2));
+ raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 3));
+ raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 4));
+ raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 5));
+ raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 6));
+ raceCheckWrite(tid, (void *)(((uintptr_t)addr) + 7));
+ (*(uint64_t *)addr) = val;
+}
+
+uint8_t load_8(const void *addr)
+{
+ DEBUG("addr = %p\n", addr);
+ thread_id_t tid = thread_current()->get_id();
+ raceCheckRead(tid, addr);
+ return *((uint8_t *)addr);
+}
+
+uint16_t load_16(const void *addr)
+{
+ DEBUG("addr = %p\n", addr);
+ thread_id_t tid = thread_current()->get_id();
+ raceCheckRead(tid, addr);
+ raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 1));
+ return *((uint16_t *)addr);
+}
+
+uint32_t load_32(const void *addr)
+{
+ DEBUG("addr = %p\n", addr);
+ thread_id_t tid = thread_current()->get_id();
+ raceCheckRead(tid, addr);
+ raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 1));
+ raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 2));
+ raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 3));
+ return *((uint32_t *)addr);
+}
+
+uint64_t load_64(const void *addr)
+{
+ DEBUG("addr = %p\n", addr);
+ thread_id_t tid = thread_current()->get_id();
+ raceCheckRead(tid, addr);
+ raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 1));
+ raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 2));
+ raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 3));
+ raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 4));
+ raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 5));
+ raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 6));
+ raceCheckRead(tid, (const void *)(((uintptr_t)addr) + 7));
+ return *((uint64_t *)addr);
+}
--- /dev/null
+#include <threads.h>
+#include "common.h"
+#include "threads-model.h"
+#include "action.h"
+
+/* global "model" object */
+#include "model.h"
+
+/*
+ * User program API functions
+ */
+int thrd_create(thrd_t *t, thrd_start_t start_routine, void *arg)
+{
+ struct thread_params params = { start_routine, arg };
+ /* seq_cst is just a 'don't care' parameter */
+ model->switch_to_master(new ModelAction(THREAD_CREATE, std::memory_order_seq_cst, t, (uint64_t)¶ms));
+ return 0;
+}
+
+int thrd_join(thrd_t t)
+{
+ Thread *th = t.priv;
+ model->switch_to_master(new ModelAction(THREAD_JOIN, std::memory_order_seq_cst, th, id_to_int(thrd_to_id(t))));
+ return 0;
+}
+
+/** A no-op, for now */
+void thrd_yield(void)
+{
+ model->switch_to_master(new ModelAction(THREAD_YIELD, std::memory_order_seq_cst, thread_current(), VALUE_NONE));
+}
+
+thrd_t thrd_current(void)
+{
+ return thread_current()->get_thrd_t();
+}
--- /dev/null
+/** @file main.cc
+ * @brief Entry point for the model checker.
+ */
+
+#include <unistd.h>
+#include <getopt.h>
+#include <string.h>
+
+#include "common.h"
+#include "output.h"
+
+#include "datarace.h"
+
+/* global "model" object */
+#include "model.h"
+#include "params.h"
+#include "snapshot-interface.h"
+#include "scanalysis.h"
+#include "plugins.h"
+
+static void param_defaults(struct model_params *params)
+{
+ params->maxreads = 0;
+ params->maxfuturedelay = 6;
+ params->fairwindow = 0;
+ params->yieldon = false;
+ params->yieldblock = false;
+ params->enabledcount = 1;
+ params->bound = 0;
+ params->maxfuturevalues = 0;
+ params->expireslop = 4;
+ params->verbose = !!DBG_ENABLED();
+ params->uninitvalue = 0;
+}
+
+static void print_usage(const char *program_name, struct model_params *params)
+{
+ ModelVector<TraceAnalysis *> * registeredanalysis=getRegisteredTraceAnalysis();
+ /* Reset defaults before printing */
+ param_defaults(params);
+
+ model_print(
+"Copyright (c) 2013 Regents of the University of California. All rights reserved.\n"
+"Distributed under the GPLv2\n"
+"Written by Brian Norris and Brian Demsky\n"
+"\n"
+"Usage: %s [MODEL-CHECKER OPTIONS] -- [PROGRAM ARGS]\n"
+"\n"
+"MODEL-CHECKER OPTIONS can be any of the model-checker options listed below. Arguments\n"
+"provided after the `--' (the PROGRAM ARGS) are passed to the user program.\n"
+"\n"
+"Model-checker options:\n"
+"-h, --help Display this help message and exit\n"
+"-m, --liveness=NUM Maximum times a thread can read from the same write\n"
+" while other writes exist.\n"
+" Default: %d\n"
+"-M, --maxfv=NUM Maximum number of future values that can be sent to\n"
+" the same read.\n"
+" Default: %d\n"
+"-s, --maxfvdelay=NUM Maximum actions that the model checker will wait for\n"
+" a write from the future past the expected number\n"
+" of actions.\n"
+" Default: %d\n"
+"-S, --fvslop=NUM Future value expiration sloppiness.\n"
+" Default: %u\n"
+"-y, --yield Enable CHESS-like yield-based fairness support\n"
+" (requires thrd_yield() in test program).\n"
+" Default: %s\n"
+"-Y, --yieldblock Prohibit an execution from running a yield.\n"
+" Default: %s\n"
+"-f, --fairness=WINDOW Specify a fairness window in which actions that are\n"
+" enabled sufficiently many times should receive\n"
+" priority for execution (not recommended).\n"
+" Default: %d\n"
+"-e, --enabled=COUNT Enabled count.\n"
+" Default: %d\n"
+"-b, --bound=MAX Upper length bound.\n"
+" Default: %d\n"
+"-v[NUM], --verbose[=NUM] Print verbose execution information. NUM is optional:\n"
+" 0 is quiet; 1 is noisy; 2 is noisier.\n"
+" Default: %d\n"
+"-u, --uninitialized=VALUE Return VALUE any load which may read from an\n"
+" uninitialized atomic.\n"
+" Default: %u\n"
+"-t, --analysis=NAME Use Analysis Plugin.\n"
+"-o, --options=NAME Option for previous analysis plugin. \n"
+" -o help for a list of options\n"
+" -- Program arguments follow.\n\n",
+ program_name,
+ params->maxreads,
+ params->maxfuturevalues,
+ params->maxfuturedelay,
+ params->expireslop,
+ params->yieldon ? "enabled" : "disabled",
+ params->yieldblock ? "enabled" : "disabled",
+ params->fairwindow,
+ params->enabledcount,
+ params->bound,
+ params->verbose,
+ params->uninitvalue);
+ model_print("Analysis plugins:\n");
+ for(unsigned int i=0;i<registeredanalysis->size();i++) {
+ TraceAnalysis * analysis=(*registeredanalysis)[i];
+ model_print("%s\n", analysis->name());
+ }
+ exit(EXIT_SUCCESS);
+}
+
+bool install_plugin(char * name) {
+ ModelVector<TraceAnalysis *> * registeredanalysis=getRegisteredTraceAnalysis();
+ ModelVector<TraceAnalysis *> * installedanalysis=getInstalledTraceAnalysis();
+
+ for(unsigned int i=0;i<registeredanalysis->size();i++) {
+ TraceAnalysis * analysis=(*registeredanalysis)[i];
+ if (strcmp(name, analysis->name())==0) {
+ installedanalysis->push_back(analysis);
+ return false;
+ }
+ }
+ model_print("Analysis %s Not Found\n", name);
+ return true;
+}
+
+static void parse_options(struct model_params *params, int argc, char **argv)
+{
+ const char *shortopts = "hyYt:o:m:M:s:S:f:e:b:u:v::";
+ const struct option longopts[] = {
+ {"help", no_argument, NULL, 'h'},
+ {"liveness", required_argument, NULL, 'm'},
+ {"maxfv", required_argument, NULL, 'M'},
+ {"maxfvdelay", required_argument, NULL, 's'},
+ {"fvslop", required_argument, NULL, 'S'},
+ {"fairness", required_argument, NULL, 'f'},
+ {"yield", no_argument, NULL, 'y'},
+ {"yieldblock", no_argument, NULL, 'Y'},
+ {"enabled", required_argument, NULL, 'e'},
+ {"bound", required_argument, NULL, 'b'},
+ {"verbose", optional_argument, NULL, 'v'},
+ {"uninitialized", optional_argument, NULL, 'u'},
+ {"analysis", optional_argument, NULL, 't'},
+ {"options", optional_argument, NULL, 'o'},
+ {0, 0, 0, 0} /* Terminator */
+ };
+ int opt, longindex;
+ bool error = false;
+ while (!error && (opt = getopt_long(argc, argv, shortopts, longopts, &longindex)) != -1) {
+ switch (opt) {
+ case 'h':
+ print_usage(argv[0], params);
+ break;
+ case 's':
+ params->maxfuturedelay = atoi(optarg);
+ break;
+ case 'S':
+ params->expireslop = atoi(optarg);
+ break;
+ case 'f':
+ params->fairwindow = atoi(optarg);
+ break;
+ case 'e':
+ params->enabledcount = atoi(optarg);
+ break;
+ case 'b':
+ params->bound = atoi(optarg);
+ break;
+ case 'm':
+ params->maxreads = atoi(optarg);
+ break;
+ case 'M':
+ params->maxfuturevalues = atoi(optarg);
+ break;
+ case 'v':
+ params->verbose = optarg ? atoi(optarg) : 1;
+ break;
+ case 'u':
+ params->uninitvalue = atoi(optarg);
+ break;
+ case 'y':
+ params->yieldon = true;
+ break;
+ case 't':
+ if (install_plugin(optarg))
+ error = true;
+ break;
+ case 'o':
+ {
+ ModelVector<TraceAnalysis *> * analyses = getInstalledTraceAnalysis();
+ if ( analyses->size() == 0 || (*analyses)[analyses->size()-1]->option(optarg))
+ error = true;
+ }
+ break;
+ case 'Y':
+ params->yieldblock = true;
+ break;
+ default: /* '?' */
+ error = true;
+ break;
+ }
+ }
+
+ /* Pass remaining arguments to user program */
+ params->argc = argc - (optind - 1);
+ params->argv = argv + (optind - 1);
+
+ /* Reset program name */
+ params->argv[0] = argv[0];
+
+ /* Reset (global) optind for potential use by user program */
+ optind = 1;
+
+ if (error)
+ print_usage(argv[0], params);
+}
+
+int main_argc;
+char **main_argv;
+
+static void install_trace_analyses(ModelExecution *execution)
+{
+ ModelVector<TraceAnalysis *> * installedanalysis=getInstalledTraceAnalysis();
+ for(unsigned int i=0;i<installedanalysis->size();i++) {
+ TraceAnalysis * ta=(*installedanalysis)[i];
+ ta->setExecution(execution);
+ model->add_trace_analysis(ta);
+ }
+}
+
+/** The model_main function contains the main model checking loop. */
+static void model_main()
+{
+ struct model_params params;
+
+ param_defaults(¶ms);
+ register_plugins();
+
+ parse_options(¶ms, main_argc, main_argv);
+
+ //Initialize race detector
+ initRaceDetector();
+
+ snapshot_stack_init();
+
+ model = new ModelChecker(params);
+ install_trace_analyses(model->get_execution());
+
+ snapshot_record(0);
+ model->run();
+ delete model;
+
+ DEBUG("Exiting\n");
+}
+
+/**
+ * Main function. Just initializes snapshotting library and the
+ * snapshotting library calls the model_main function.
+ */
+int main(int argc, char **argv)
+{
+ main_argc = argc;
+ main_argv = argv;
+
+ /* Configure output redirection for the model-checker */
+ redirect_output();
+
+ /* Let's jump in quickly and start running stuff */
+ snapshot_system_init(10000, 1024, 1024, 4000, &model_main);
+}
--- /dev/null
+/**
+ * @mainpage
+ * @htmlinclude README.html
+ */
--- /dev/null
+/*
+ This is a version (aka dlmalloc) of malloc/free/realloc written by
+ Doug Lea and released to the public domain, as explained at
+ http://creativecommons.org/publicdomain/zero/1.0/ Send questions,
+ comments, complaints, performance data, etc to dl@cs.oswego.edu
+
+* Version 2.8.5 Sun May 22 10:26:02 2011 Doug Lea (dl at gee)
+
+ Note: There may be an updated version of this malloc obtainable at
+ ftp://gee.cs.oswego.edu/pub/misc/malloc.c
+ Check before installing!
+
+* Quickstart
+
+ This library is all in one file to simplify the most common usage:
+ ftp it, compile it (-O3), and link it into another program. All of
+ the compile-time options default to reasonable values for use on
+ most platforms. You might later want to step through various
+ compile-time and dynamic tuning options.
+
+ For convenience, an include file for code using this malloc is at:
+ ftp://gee.cs.oswego.edu/pub/misc/malloc-2.8.5.h
+ You don't really need this .h file unless you call functions not
+ defined in your system include files. The .h file contains only the
+ excerpts from this file needed for using this malloc on ANSI C/C++
+ systems, so long as you haven't changed compile-time options about
+ naming and tuning parameters. If you do, then you can create your
+ own malloc.h that does include all settings by cutting at the point
+ indicated below. Note that you may already by default be using a C
+ library containing a malloc that is based on some version of this
+ malloc (for example in linux). You might still want to use the one
+ in this file to customize settings or to avoid overheads associated
+ with library versions.
+
+* Vital statistics:
+
+ Supported pointer/size_t representation: 4 or 8 bytes
+ size_t MUST be an unsigned type of the same width as
+ pointers. (If you are using an ancient system that declares
+ size_t as a signed type, or need it to be a different width
+ than pointers, you can use a previous release of this malloc
+ (e.g. 2.7.2) supporting these.)
+
+ Alignment: 8 bytes (default)
+ This suffices for nearly all current machines and C compilers.
+ However, you can define MALLOC_ALIGNMENT to be wider than this
+ if necessary (up to 128bytes), at the expense of using more space.
+
+ Minimum overhead per allocated chunk: 4 or 8 bytes (if 4byte sizes)
+ 8 or 16 bytes (if 8byte sizes)
+ Each malloced chunk has a hidden word of overhead holding size
+ and status information, and additional cross-check word
+ if FOOTERS is defined.
+
+ Minimum allocated size: 4-byte ptrs: 16 bytes (including overhead)
+ 8-byte ptrs: 32 bytes (including overhead)
+
+ Even a request for zero bytes (i.e., malloc(0)) returns a
+ pointer to something of the minimum allocatable size.
+ The maximum overhead wastage (i.e., number of extra bytes
+ allocated than were requested in malloc) is less than or equal
+ to the minimum size, except for requests >= mmap_threshold that
+ are serviced via mmap(), where the worst case wastage is about
+ 32 bytes plus the remainder from a system page (the minimal
+ mmap unit); typically 4096 or 8192 bytes.
+
+ Security: static-safe; optionally more or less
+ The "security" of malloc refers to the ability of malicious
+ code to accentuate the effects of errors (for example, freeing
+ space that is not currently malloc'ed or overwriting past the
+ ends of chunks) in code that calls malloc. This malloc
+ guarantees not to modify any memory locations below the base of
+ heap, i.e., static variables, even in the presence of usage
+ errors. The routines additionally detect most improper frees
+ and reallocs. All this holds as long as the static bookkeeping
+ for malloc itself is not corrupted by some other means. This
+ is only one aspect of security -- these checks do not, and
+ cannot, detect all possible programming errors.
+
+ If FOOTERS is defined nonzero, then each allocated chunk
+ carries an additional check word to verify that it was malloced
+ from its space. These check words are the same within each
+ execution of a program using malloc, but differ across
+ executions, so externally crafted fake chunks cannot be
+ freed. This improves security by rejecting frees/reallocs that
+ could corrupt heap memory, in addition to the checks preventing
+ writes to statics that are always on. This may further improve
+ security at the expense of time and space overhead. (Note that
+ FOOTERS may also be worth using with MSPACES.)
+
+ By default detected errors cause the program to abort (calling
+ "abort()"). You can override this to instead proceed past
+ errors by defining PROCEED_ON_ERROR. In this case, a bad free
+ has no effect, and a malloc that encounters a bad address
+ caused by user overwrites will ignore the bad address by
+ dropping pointers and indices to all known memory. This may
+ be appropriate for programs that should continue if at all
+ possible in the face of programming errors, although they may
+ run out of memory because dropped memory is never reclaimed.
+
+ If you don't like either of these options, you can define
+ CORRUPTION_ERROR_ACTION and USAGE_ERROR_ACTION to do anything
+ else. And if if you are sure that your program using malloc has
+ no errors or vulnerabilities, you can define INSECURE to 1,
+ which might (or might not) provide a small performance improvement.
+
+ It is also possible to limit the maximum total allocatable
+ space, using malloc_set_footprint_limit. This is not
+ designed as a security feature in itself (calls to set limits
+ are not screened or privileged), but may be useful as one
+ aspect of a secure implementation.
+
+ Thread-safety: NOT thread-safe unless USE_LOCKS defined non-zero
+ When USE_LOCKS is defined, each public call to malloc, free,
+ etc is surrounded with a lock. By default, this uses a plain
+ pthread mutex, win32 critical section, or a spin-lock if if
+ available for the platform and not disabled by setting
+ USE_SPIN_LOCKS=0. However, if USE_RECURSIVE_LOCKS is defined,
+ recursive versions are used instead (which are not required for
+ base functionality but may be needed in layered extensions).
+ Using a global lock is not especially fast, and can be a major
+ bottleneck. It is designed only to provide minimal protection
+ in concurrent environments, and to provide a basis for
+ extensions. If you are using malloc in a concurrent program,
+ consider instead using nedmalloc
+ (http://www.nedprod.com/programs/portable/nedmalloc/) or
+ ptmalloc (See http://www.malloc.de), which are derived from
+ versions of this malloc.
+
+ System requirements: Any combination of MORECORE and/or MMAP/MUNMAP
+ This malloc can use unix sbrk or any emulation (invoked using
+ the CALL_MORECORE macro) and/or mmap/munmap or any emulation
+ (invoked using CALL_MMAP/CALL_MUNMAP) to get and release system
+ memory. On most unix systems, it tends to work best if both
+ MORECORE and MMAP are enabled. On Win32, it uses emulations
+ based on VirtualAlloc. It also uses common C library functions
+ like memset.
+
+ Compliance: I believe it is compliant with the Single Unix Specification
+ (See http://www.unix.org). Also SVID/XPG, ANSI C, and probably
+ others as well.
+
+* Overview of algorithms
+
+ This is not the fastest, most space-conserving, most portable, or
+ most tunable malloc ever written. However it is among the fastest
+ while also being among the most space-conserving, portable and
+ tunable. Consistent balance across these factors results in a good
+ general-purpose allocator for malloc-intensive programs.
+
+ In most ways, this malloc is a best-fit allocator. Generally, it
+ chooses the best-fitting existing chunk for a request, with ties
+ broken in approximately least-recently-used order. (This strategy
+ normally maintains low fragmentation.) However, for requests less
+ than 256bytes, it deviates from best-fit when there is not an
+ exactly fitting available chunk by preferring to use space adjacent
+ to that used for the previous small request, as well as by breaking
+ ties in approximately most-recently-used order. (These enhance
+ locality of series of small allocations.) And for very large requests
+ (>= 256Kb by default), it relies on system memory mapping
+ facilities, if supported. (This helps avoid carrying around and
+ possibly fragmenting memory used only for large chunks.)
+
+ All operations (except malloc_stats and mallinfo) have execution
+ times that are bounded by a constant factor of the number of bits in
+ a size_t, not counting any clearing in calloc or copying in realloc,
+ or actions surrounding MORECORE and MMAP that have times
+ proportional to the number of non-contiguous regions returned by
+ system allocation routines, which is often just 1. In real-time
+ applications, you can optionally suppress segment traversals using
+ NO_SEGMENT_TRAVERSAL, which assures bounded execution even when
+ system allocators return non-contiguous spaces, at the typical
+ expense of carrying around more memory and increased fragmentation.
+
+ The implementation is not very modular and seriously overuses
+ macros. Perhaps someday all C compilers will do as good a job
+ inlining modular code as can now be done by brute-force expansion,
+ but now, enough of them seem not to.
+
+ Some compilers issue a lot of warnings about code that is
+ dead/unreachable only on some platforms, and also about intentional
+ uses of negation on unsigned types. All known cases of each can be
+ ignored.
+
+ For a longer but out of date high-level description, see
+ http://gee.cs.oswego.edu/dl/html/malloc.html
+
+* MSPACES
+ If MSPACES is defined, then in addition to malloc, free, etc.,
+ this file also defines mspace_malloc, mspace_free, etc. These
+ are versions of malloc routines that take an "mspace" argument
+ obtained using create_mspace, to control all internal bookkeeping.
+ If ONLY_MSPACES is defined, only these versions are compiled.
+ So if you would like to use this allocator for only some allocations,
+ and your system malloc for others, you can compile with
+ ONLY_MSPACES and then do something like...
+ static mspace mymspace = create_mspace(0,0); // for example
+ #define mymalloc(bytes) mspace_malloc(mymspace, bytes)
+
+ (Note: If you only need one instance of an mspace, you can instead
+ use "USE_DL_PREFIX" to relabel the global malloc.)
+
+ You can similarly create thread-local allocators by storing
+ mspaces as thread-locals. For example:
+ static __thread mspace tlms = 0;
+ void* tlmalloc(size_t bytes) {
+ if (tlms == 0) tlms = create_mspace(0, 0);
+ return mspace_malloc(tlms, bytes);
+ }
+ void tlfree(void* mem) { mspace_free(tlms, mem); }
+
+ Unless FOOTERS is defined, each mspace is completely independent.
+ You cannot allocate from one and free to another (although
+ conformance is only weakly checked, so usage errors are not always
+ caught). If FOOTERS is defined, then each chunk carries around a tag
+ indicating its originating mspace, and frees are directed to their
+ originating spaces. Normally, this requires use of locks.
+
+ ------------------------- Compile-time options ---------------------------
+
+Be careful in setting #define values for numerical constants of type
+size_t. On some systems, literal values are not automatically extended
+to size_t precision unless they are explicitly casted. You can also
+use the symbolic values MAX_SIZE_T, SIZE_T_ONE, etc below.
+
+WIN32 default: defined if _WIN32 defined
+ Defining WIN32 sets up defaults for MS environment and compilers.
+ Otherwise defaults are for unix. Beware that there seem to be some
+ cases where this malloc might not be a pure drop-in replacement for
+ Win32 malloc: Random-looking failures from Win32 GDI API's (eg;
+ SetDIBits()) may be due to bugs in some video driver implementations
+ when pixel buffers are malloc()ed, and the region spans more than
+ one VirtualAlloc()ed region. Because dlmalloc uses a small (64Kb)
+ default granularity, pixel buffers may straddle virtual allocation
+ regions more often than when using the Microsoft allocator. You can
+ avoid this by using VirtualAlloc() and VirtualFree() for all pixel
+ buffers rather than using malloc(). If this is not possible,
+ recompile this malloc with a larger DEFAULT_GRANULARITY. Note:
+ in cases where MSC and gcc (cygwin) are known to differ on WIN32,
+ conditions use _MSC_VER to distinguish them.
+
+DLMALLOC_EXPORT default: extern
+ Defines how public APIs are declared. If you want to export via a
+ Windows DLL, you might define this as
+ #define DLMALLOC_EXPORT extern __declspace(dllexport)
+ If you want a POSIX ELF shared object, you might use
+ #define DLMALLOC_EXPORT extern __attribute__((visibility("default")))
+
+MALLOC_ALIGNMENT default: (size_t)8
+ Controls the minimum alignment for malloc'ed chunks. It must be a
+ power of two and at least 8, even on machines for which smaller
+ alignments would suffice. It may be defined as larger than this
+ though. Note however that code and data structures are optimized for
+ the case of 8-byte alignment.
+
+MSPACES default: 0 (false)
+ If true, compile in support for independent allocation spaces.
+ This is only supported if HAVE_MMAP is true.
+
+ONLY_MSPACES default: 0 (false)
+ If true, only compile in mspace versions, not regular versions.
+
+USE_LOCKS default: 0 (false)
+ Causes each call to each public routine to be surrounded with
+ pthread or WIN32 mutex lock/unlock. (If set true, this can be
+ overridden on a per-mspace basis for mspace versions.) If set to a
+ non-zero value other than 1, locks are used, but their
+ implementation is left out, so lock functions must be supplied manually,
+ as described below.
+
+USE_SPIN_LOCKS default: 1 iff USE_LOCKS and spin locks available
+ If true, uses custom spin locks for locking. This is currently
+ supported only gcc >= 4.1, older gccs on x86 platforms, and recent
+ MS compilers. Otherwise, posix locks or win32 critical sections are
+ used.
+
+USE_RECURSIVE_LOCKS default: not defined
+ If defined nonzero, uses recursive (aka reentrant) locks, otherwise
+ uses plain mutexes. This is not required for malloc proper, but may
+ be needed for layered allocators such as nedmalloc.
+
+FOOTERS default: 0
+ If true, provide extra checking and dispatching by placing
+ information in the footers of allocated chunks. This adds
+ space and time overhead.
+
+INSECURE default: 0
+ If true, omit checks for usage errors and heap space overwrites.
+
+USE_DL_PREFIX default: NOT defined
+ Causes compiler to prefix all public routines with the string 'dl'.
+ This can be useful when you only want to use this malloc in one part
+ of a program, using your regular system malloc elsewhere.
+
+MALLOC_INSPECT_ALL default: NOT defined
+ If defined, compiles malloc_inspect_all and mspace_inspect_all, that
+ perform traversal of all heap space. Unless access to these
+ functions is otherwise restricted, you probably do not want to
+ include them in secure implementations.
+
+ABORT default: defined as abort()
+ Defines how to abort on failed checks. On most systems, a failed
+ check cannot die with an "assert" or even print an informative
+ message, because the underlying print routines in turn call malloc,
+ which will fail again. Generally, the best policy is to simply call
+ abort(). It's not very useful to do more than this because many
+ errors due to overwriting will show up as address faults (null, odd
+ addresses etc) rather than malloc-triggered checks, so will also
+ abort. Also, most compilers know that abort() does not return, so
+ can better optimize code conditionally calling it.
+
+PROCEED_ON_ERROR default: defined as 0 (false)
+ Controls whether detected bad addresses cause them to bypassed
+ rather than aborting. If set, detected bad arguments to free and
+ realloc are ignored. And all bookkeeping information is zeroed out
+ upon a detected overwrite of freed heap space, thus losing the
+ ability to ever return it from malloc again, but enabling the
+ application to proceed. If PROCEED_ON_ERROR is defined, the
+ static variable malloc_corruption_error_count is compiled in
+ and can be examined to see if errors have occurred. This option
+ generates slower code than the default abort policy.
+
+DEBUG default: NOT defined
+ The DEBUG setting is mainly intended for people trying to modify
+ this code or diagnose problems when porting to new platforms.
+ However, it may also be able to better isolate user errors than just
+ using runtime checks. The assertions in the check routines spell
+ out in more detail the assumptions and invariants underlying the
+ algorithms. The checking is fairly extensive, and will slow down
+ execution noticeably. Calling malloc_stats or mallinfo with DEBUG
+ set will attempt to check every non-mmapped allocated and free chunk
+ in the course of computing the summaries.
+
+ABORT_ON_ASSERT_FAILURE default: defined as 1 (true)
+ Debugging assertion failures can be nearly impossible if your
+ version of the assert macro causes malloc to be called, which will
+ lead to a cascade of further failures, blowing the runtime stack.
+ ABORT_ON_ASSERT_FAILURE cause assertions failures to call abort(),
+ which will usually make debugging easier.
+
+MALLOC_FAILURE_ACTION default: sets errno to ENOMEM, or no-op on win32
+ The action to take before "return 0" when malloc fails to be able to
+ return memory because there is none available.
+
+HAVE_MORECORE default: 1 (true) unless win32 or ONLY_MSPACES
+ True if this system supports sbrk or an emulation of it.
+
+MORECORE default: sbrk
+ The name of the sbrk-style system routine to call to obtain more
+ memory. See below for guidance on writing custom MORECORE
+ functions. The type of the argument to sbrk/MORECORE varies across
+ systems. It cannot be size_t, because it supports negative
+ arguments, so it is normally the signed type of the same width as
+ size_t (sometimes declared as "intptr_t"). It doesn't much matter
+ though. Internally, we only call it with arguments less than half
+ the max value of a size_t, which should work across all reasonable
+ possibilities, although sometimes generating compiler warnings.
+
+MORECORE_CONTIGUOUS default: 1 (true) if HAVE_MORECORE
+ If true, take advantage of fact that consecutive calls to MORECORE
+ with positive arguments always return contiguous increasing
+ addresses. This is true of unix sbrk. It does not hurt too much to
+ set it true anyway, since malloc copes with non-contiguities.
+ Setting it false when definitely non-contiguous saves time
+ and possibly wasted space it would take to discover this though.
+
+MORECORE_CANNOT_TRIM default: NOT defined
+ True if MORECORE cannot release space back to the system when given
+ negative arguments. This is generally necessary only if you are
+ using a hand-crafted MORECORE function that cannot handle negative
+ arguments.
+
+NO_SEGMENT_TRAVERSAL default: 0
+ If non-zero, suppresses traversals of memory segments
+ returned by either MORECORE or CALL_MMAP. This disables
+ merging of segments that are contiguous, and selectively
+ releasing them to the OS if unused, but bounds execution times.
+
+HAVE_MMAP default: 1 (true)
+ True if this system supports mmap or an emulation of it. If so, and
+ HAVE_MORECORE is not true, MMAP is used for all system
+ allocation. If set and HAVE_MORECORE is true as well, MMAP is
+ primarily used to directly allocate very large blocks. It is also
+ used as a backup strategy in cases where MORECORE fails to provide
+ space from system. Note: A single call to MUNMAP is assumed to be
+ able to unmap memory that may have be allocated using multiple calls
+ to MMAP, so long as they are adjacent.
+
+HAVE_MREMAP default: 1 on linux, else 0
+ If true realloc() uses mremap() to re-allocate large blocks and
+ extend or shrink allocation spaces.
+
+MMAP_CLEARS default: 1 except on WINCE.
+ True if mmap clears memory so calloc doesn't need to. This is true
+ for standard unix mmap using /dev/zero and on WIN32 except for WINCE.
+
+USE_BUILTIN_FFS default: 0 (i.e., not used)
+ Causes malloc to use the builtin ffs() function to compute indices.
+ Some compilers may recognize and intrinsify ffs to be faster than the
+ supplied C version. Also, the case of x86 using gcc is special-cased
+ to an asm instruction, so is already as fast as it can be, and so
+ this setting has no effect. Similarly for Win32 under recent MS compilers.
+ (On most x86s, the asm version is only slightly faster than the C version.)
+
+malloc_getpagesize default: derive from system includes, or 4096.
+ The system page size. To the extent possible, this malloc manages
+ memory from the system in page-size units. This may be (and
+ usually is) a function rather than a constant. This is ignored
+ if WIN32, where page size is determined using getSystemInfo during
+ initialization.
+
+USE_DEV_RANDOM default: 0 (i.e., not used)
+ Causes malloc to use /dev/random to initialize secure magic seed for
+ stamping footers. Otherwise, the current time is used.
+
+NO_MALLINFO default: 0
+ If defined, don't compile "mallinfo". This can be a simple way
+ of dealing with mismatches between system declarations and
+ those in this file.
+
+MALLINFO_FIELD_TYPE default: size_t
+ The type of the fields in the mallinfo struct. This was originally
+ defined as "int" in SVID etc, but is more usefully defined as
+ size_t. The value is used only if HAVE_USR_INCLUDE_MALLOC_H is not set
+
+NO_MALLOC_STATS default: 0
+ If defined, don't compile "malloc_stats". This avoids calls to
+ fprintf and bringing in stdio dependencies you might not want.
+
+REALLOC_ZERO_BYTES_FREES default: not defined
+ This should be set if a call to realloc with zero bytes should
+ be the same as a call to free. Some people think it should. Otherwise,
+ since this malloc returns a unique pointer for malloc(0), so does
+ realloc(p, 0).
+
+LACKS_UNISTD_H, LACKS_FCNTL_H, LACKS_SYS_PARAM_H, LACKS_SYS_MMAN_H
+LACKS_STRINGS_H, LACKS_STRING_H, LACKS_SYS_TYPES_H, LACKS_ERRNO_H
+LACKS_STDLIB_H LACKS_SCHED_H LACKS_TIME_H default: NOT defined unless on WIN32
+ Define these if your system does not have these header files.
+ You might need to manually insert some of the declarations they provide.
+
+DEFAULT_GRANULARITY default: page size if MORECORE_CONTIGUOUS,
+ system_info.dwAllocationGranularity in WIN32,
+ otherwise 64K.
+ Also settable using mallopt(M_GRANULARITY, x)
+ The unit for allocating and deallocating memory from the system. On
+ most systems with contiguous MORECORE, there is no reason to
+ make this more than a page. However, systems with MMAP tend to
+ either require or encourage larger granularities. You can increase
+ this value to prevent system allocation functions to be called so
+ often, especially if they are slow. The value must be at least one
+ page and must be a power of two. Setting to 0 causes initialization
+ to either page size or win32 region size. (Note: In previous
+ versions of malloc, the equivalent of this option was called
+ "TOP_PAD")
+
+DEFAULT_TRIM_THRESHOLD default: 2MB
+ Also settable using mallopt(M_TRIM_THRESHOLD, x)
+ The maximum amount of unused top-most memory to keep before
+ releasing via malloc_trim in free(). Automatic trimming is mainly
+ useful in long-lived programs using contiguous MORECORE. Because
+ trimming via sbrk can be slow on some systems, and can sometimes be
+ wasteful (in cases where programs immediately afterward allocate
+ more large chunks) the value should be high enough so that your
+ overall system performance would improve by releasing this much
+ memory. As a rough guide, you might set to a value close to the
+ average size of a process (program) running on your system.
+ Releasing this much memory would allow such a process to run in
+ memory. Generally, it is worth tuning trim thresholds when a
+ program undergoes phases where several large chunks are allocated
+ and released in ways that can reuse each other's storage, perhaps
+ mixed with phases where there are no such chunks at all. The trim
+ value must be greater than page size to have any useful effect. To
+ disable trimming completely, you can set to MAX_SIZE_T. Note that the trick
+ some people use of mallocing a huge space and then freeing it at
+ program startup, in an attempt to reserve system memory, doesn't
+ have the intended effect under automatic trimming, since that memory
+ will immediately be returned to the system.
+
+DEFAULT_MMAP_THRESHOLD default: 256K
+ Also settable using mallopt(M_MMAP_THRESHOLD, x)
+ The request size threshold for using MMAP to directly service a
+ request. Requests of at least this size that cannot be allocated
+ using already-existing space will be serviced via mmap. (If enough
+ normal freed space already exists it is used instead.) Using mmap
+ segregates relatively large chunks of memory so that they can be
+ individually obtained and released from the host system. A request
+ serviced through mmap is never reused by any other request (at least
+ not directly; the system may just so happen to remap successive
+ requests to the same locations). Segregating space in this way has
+ the benefits that: Mmapped space can always be individually released
+ back to the system, which helps keep the system level memory demands
+ of a long-lived program low. Also, mapped memory doesn't become
+ `locked' between other chunks, as can happen with normally allocated
+ chunks, which means that even trimming via malloc_trim would not
+ release them. However, it has the disadvantage that the space
+ cannot be reclaimed, consolidated, and then used to service later
+ requests, as happens with normal chunks. The advantages of mmap
+ nearly always outweigh disadvantages for "large" chunks, but the
+ value of "large" may vary across systems. The default is an
+ empirically derived value that works well in most systems. You can
+ disable mmap by setting to MAX_SIZE_T.
+
+MAX_RELEASE_CHECK_RATE default: 4095 unless not HAVE_MMAP
+ The number of consolidated frees between checks to release
+ unused segments when freeing. When using non-contiguous segments,
+ especially with multiple mspaces, checking only for topmost space
+ doesn't always suffice to trigger trimming. To compensate for this,
+ free() will, with a period of MAX_RELEASE_CHECK_RATE (or the
+ current number of segments, if greater) try to release unused
+ segments to the OS when freeing chunks that result in
+ consolidation. The best value for this parameter is a compromise
+ between slowing down frees with relatively costly checks that
+ rarely trigger versus holding on to unused memory. To effectively
+ disable, set to MAX_SIZE_T. This may lead to a very slight speed
+ improvement at the expense of carrying around more memory.
+*/
+
+/* Version identifier to allow people to support multiple versions */
+#ifndef DLMALLOC_VERSION
+#define DLMALLOC_VERSION 20805
+#endif /* DLMALLOC_VERSION */
+
+#ifndef DLMALLOC_EXPORT
+#define DLMALLOC_EXPORT extern
+#endif
+
+#ifndef WIN32
+#ifdef _WIN32
+#define WIN32 1
+#endif /* _WIN32 */
+#ifdef _WIN32_WCE
+#define LACKS_FCNTL_H
+#define WIN32 1
+#endif /* _WIN32_WCE */
+#endif /* WIN32 */
+#ifdef WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <tchar.h>
+#define HAVE_MMAP 1
+#define HAVE_MORECORE 0
+#define LACKS_UNISTD_H
+#define LACKS_SYS_PARAM_H
+#define LACKS_SYS_MMAN_H
+#define LACKS_STRING_H
+#define LACKS_STRINGS_H
+#define LACKS_SYS_TYPES_H
+#define LACKS_ERRNO_H
+#define LACKS_SCHED_H
+#ifndef MALLOC_FAILURE_ACTION
+#define MALLOC_FAILURE_ACTION
+#endif /* MALLOC_FAILURE_ACTION */
+#ifndef MMAP_CLEARS
+#ifdef _WIN32_WCE /* WINCE reportedly does not clear */
+#define MMAP_CLEARS 0
+#else
+#define MMAP_CLEARS 1
+#endif /* _WIN32_WCE */
+#endif /*MMAP_CLEARS */
+#endif /* WIN32 */
+
+#if defined(DARWIN) || defined(_DARWIN)
+/* Mac OSX docs advise not to use sbrk; it seems better to use mmap */
+#ifndef HAVE_MORECORE
+#define HAVE_MORECORE 0
+#define HAVE_MMAP 1
+/* OSX allocators provide 16 byte alignment */
+#ifndef MALLOC_ALIGNMENT
+#define MALLOC_ALIGNMENT ((size_t)16U)
+#endif
+#endif /* HAVE_MORECORE */
+#endif /* DARWIN */
+
+#ifndef LACKS_SYS_TYPES_H
+#include <sys/types.h> /* For size_t */
+#endif /* LACKS_SYS_TYPES_H */
+
+/* The maximum possible size_t value has all bits set */
+#define MAX_SIZE_T (~(size_t)0)
+
+#ifndef USE_LOCKS /* ensure true if spin or recursive locks set */
+#define USE_LOCKS ((defined(USE_SPIN_LOCKS) && USE_SPIN_LOCKS != 0) || \
+ (defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0))
+#endif /* USE_LOCKS */
+
+#if USE_LOCKS /* Spin locks for gcc >= 4.1, older gcc on x86, MSC >= 1310 */
+#if ((defined(__GNUC__) && \
+ ((__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) || \
+ defined(__i386__) || defined(__x86_64__))) || \
+ (defined(_MSC_VER) && _MSC_VER>=1310))
+#ifndef USE_SPIN_LOCKS
+#define USE_SPIN_LOCKS 1
+#endif /* USE_SPIN_LOCKS */
+#elif USE_SPIN_LOCKS
+#error "USE_SPIN_LOCKS defined without implementation"
+#endif /* ... locks available... */
+#elif !defined(USE_SPIN_LOCKS)
+#define USE_SPIN_LOCKS 0
+#endif /* USE_LOCKS */
+
+#ifndef ONLY_MSPACES
+#define ONLY_MSPACES 0
+#endif /* ONLY_MSPACES */
+#ifndef MSPACES
+#if ONLY_MSPACES
+#define MSPACES 1
+#else /* ONLY_MSPACES */
+#define MSPACES 0
+#endif /* ONLY_MSPACES */
+#endif /* MSPACES */
+#ifndef MALLOC_ALIGNMENT
+#define MALLOC_ALIGNMENT ((size_t)8U)
+#endif /* MALLOC_ALIGNMENT */
+#ifndef FOOTERS
+#define FOOTERS 0
+#endif /* FOOTERS */
+#ifndef ABORT
+#define ABORT abort()
+#endif /* ABORT */
+#ifndef ABORT_ON_ASSERT_FAILURE
+#define ABORT_ON_ASSERT_FAILURE 1
+#endif /* ABORT_ON_ASSERT_FAILURE */
+#ifndef PROCEED_ON_ERROR
+#define PROCEED_ON_ERROR 0
+#endif /* PROCEED_ON_ERROR */
+
+#ifndef INSECURE
+#define INSECURE 0
+#endif /* INSECURE */
+#ifndef MALLOC_INSPECT_ALL
+#define MALLOC_INSPECT_ALL 0
+#endif /* MALLOC_INSPECT_ALL */
+#ifndef HAVE_MMAP
+#define HAVE_MMAP 1
+#endif /* HAVE_MMAP */
+#ifndef MMAP_CLEARS
+#define MMAP_CLEARS 1
+#endif /* MMAP_CLEARS */
+#ifndef HAVE_MREMAP
+#ifdef linux
+#define HAVE_MREMAP 1
+#define _GNU_SOURCE /* Turns on mremap() definition */
+#else /* linux */
+#define HAVE_MREMAP 0
+#endif /* linux */
+#endif /* HAVE_MREMAP */
+#ifndef MALLOC_FAILURE_ACTION
+#define MALLOC_FAILURE_ACTION errno = ENOMEM;
+#endif /* MALLOC_FAILURE_ACTION */
+#ifndef HAVE_MORECORE
+#if ONLY_MSPACES
+#define HAVE_MORECORE 0
+#else /* ONLY_MSPACES */
+#define HAVE_MORECORE 1
+#endif /* ONLY_MSPACES */
+#endif /* HAVE_MORECORE */
+#if !HAVE_MORECORE
+#define MORECORE_CONTIGUOUS 0
+#else /* !HAVE_MORECORE */
+#define MORECORE_DEFAULT sbrk
+#ifndef MORECORE_CONTIGUOUS
+#define MORECORE_CONTIGUOUS 1
+#endif /* MORECORE_CONTIGUOUS */
+#endif /* HAVE_MORECORE */
+#ifndef DEFAULT_GRANULARITY
+#if (MORECORE_CONTIGUOUS || defined(WIN32))
+#define DEFAULT_GRANULARITY (0) /* 0 means to compute in init_mparams */
+#else /* MORECORE_CONTIGUOUS */
+#define DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U)
+#endif /* MORECORE_CONTIGUOUS */
+#endif /* DEFAULT_GRANULARITY */
+#ifndef DEFAULT_TRIM_THRESHOLD
+#ifndef MORECORE_CANNOT_TRIM
+#define DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U)
+#else /* MORECORE_CANNOT_TRIM */
+#define DEFAULT_TRIM_THRESHOLD MAX_SIZE_T
+#endif /* MORECORE_CANNOT_TRIM */
+#endif /* DEFAULT_TRIM_THRESHOLD */
+#ifndef DEFAULT_MMAP_THRESHOLD
+#if HAVE_MMAP
+#define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)
+#else /* HAVE_MMAP */
+#define DEFAULT_MMAP_THRESHOLD MAX_SIZE_T
+#endif /* HAVE_MMAP */
+#endif /* DEFAULT_MMAP_THRESHOLD */
+#ifndef MAX_RELEASE_CHECK_RATE
+#if HAVE_MMAP
+#define MAX_RELEASE_CHECK_RATE 4095
+#else
+#define MAX_RELEASE_CHECK_RATE MAX_SIZE_T
+#endif /* HAVE_MMAP */
+#endif /* MAX_RELEASE_CHECK_RATE */
+#ifndef USE_BUILTIN_FFS
+#define USE_BUILTIN_FFS 0
+#endif /* USE_BUILTIN_FFS */
+#ifndef USE_DEV_RANDOM
+#define USE_DEV_RANDOM 0
+#endif /* USE_DEV_RANDOM */
+#ifndef NO_MALLINFO
+#define NO_MALLINFO 0
+#endif /* NO_MALLINFO */
+#ifndef MALLINFO_FIELD_TYPE
+#define MALLINFO_FIELD_TYPE size_t
+#endif /* MALLINFO_FIELD_TYPE */
+#ifndef NO_MALLOC_STATS
+#define NO_MALLOC_STATS 0
+#endif /* NO_MALLOC_STATS */
+#ifndef NO_SEGMENT_TRAVERSAL
+#define NO_SEGMENT_TRAVERSAL 0
+#endif /* NO_SEGMENT_TRAVERSAL */
+
+/*
+ mallopt tuning options. SVID/XPG defines four standard parameter
+ numbers for mallopt, normally defined in malloc.h. None of these
+ are used in this malloc, so setting them has no effect. But this
+ malloc does support the following options.
+*/
+
+#define M_TRIM_THRESHOLD (-1)
+#define M_GRANULARITY (-2)
+#define M_MMAP_THRESHOLD (-3)
+
+/* ------------------------ Mallinfo declarations ------------------------ */
+
+#if !NO_MALLINFO
+/*
+ This version of malloc supports the standard SVID/XPG mallinfo
+ routine that returns a struct containing usage properties and
+ statistics. It should work on any system that has a
+ /usr/include/malloc.h defining struct mallinfo. The main
+ declaration needed is the mallinfo struct that is returned (by-copy)
+ by mallinfo(). The malloinfo struct contains a bunch of fields that
+ are not even meaningful in this version of malloc. These fields are
+ are instead filled by mallinfo() with other numbers that might be of
+ interest.
+
+ HAVE_USR_INCLUDE_MALLOC_H should be set if you have a
+ /usr/include/malloc.h file that includes a declaration of struct
+ mallinfo. If so, it is included; else a compliant version is
+ declared below. These must be precisely the same for mallinfo() to
+ work. The original SVID version of this struct, defined on most
+ systems with mallinfo, declares all fields as ints. But some others
+ define as unsigned long. If your system defines the fields using a
+ type of different width than listed here, you MUST #include your
+ system version and #define HAVE_USR_INCLUDE_MALLOC_H.
+*/
+
+/* #define HAVE_USR_INCLUDE_MALLOC_H */
+
+#ifdef HAVE_USR_INCLUDE_MALLOC_H
+#include "/usr/include/malloc.h"
+#else /* HAVE_USR_INCLUDE_MALLOC_H */
+#ifndef STRUCT_MALLINFO_DECLARED
+/* HP-UX (and others?) redefines mallinfo unless _STRUCT_MALLINFO is defined */
+#define _STRUCT_MALLINFO
+#define STRUCT_MALLINFO_DECLARED 1
+struct mallinfo {
+ MALLINFO_FIELD_TYPE arena; /* non-mmapped space allocated from system */
+ MALLINFO_FIELD_TYPE ordblks; /* number of free chunks */
+ MALLINFO_FIELD_TYPE smblks; /* always 0 */
+ MALLINFO_FIELD_TYPE hblks; /* always 0 */
+ MALLINFO_FIELD_TYPE hblkhd; /* space in mmapped regions */
+ MALLINFO_FIELD_TYPE usmblks; /* maximum total allocated space */
+ MALLINFO_FIELD_TYPE fsmblks; /* always 0 */
+ MALLINFO_FIELD_TYPE uordblks; /* total allocated space */
+ MALLINFO_FIELD_TYPE fordblks; /* total free space */
+ MALLINFO_FIELD_TYPE keepcost; /* releasable (via malloc_trim) space */
+};
+#endif /* STRUCT_MALLINFO_DECLARED */
+#endif /* HAVE_USR_INCLUDE_MALLOC_H */
+#endif /* NO_MALLINFO */
+
+/*
+ Try to persuade compilers to inline. The most critical functions for
+ inlining are defined as macros, so these aren't used for them.
+*/
+
+#ifndef FORCEINLINE
+ #if defined(__GNUC__)
+#define FORCEINLINE __inline __attribute__ ((always_inline))
+ #elif defined(_MSC_VER)
+ #define FORCEINLINE __forceinline
+ #endif
+#endif
+#ifndef NOINLINE
+ #if defined(__GNUC__)
+ #define NOINLINE __attribute__ ((noinline))
+ #elif defined(_MSC_VER)
+ #define NOINLINE __declspec(noinline)
+ #else
+ #define NOINLINE
+ #endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#ifndef FORCEINLINE
+ #define FORCEINLINE inline
+#endif
+#endif /* __cplusplus */
+#ifndef FORCEINLINE
+ #define FORCEINLINE
+#endif
+
+#if !ONLY_MSPACES
+
+/* ------------------- Declarations of public routines ------------------- */
+
+#ifndef USE_DL_PREFIX
+#define dlcalloc calloc
+#define dlfree free
+#define dlmalloc malloc
+#define dlmemalign memalign
+#define dlposix_memalign posix_memalign
+#define dlrealloc realloc
+#define dlrealloc_in_place realloc_in_place
+#define dlvalloc valloc
+#define dlpvalloc pvalloc
+#define dlmallinfo mallinfo
+#define dlmallopt mallopt
+#define dlmalloc_trim malloc_trim
+#define dlmalloc_stats malloc_stats
+#define dlmalloc_usable_size malloc_usable_size
+#define dlmalloc_footprint malloc_footprint
+#define dlmalloc_max_footprint malloc_max_footprint
+#define dlmalloc_footprint_limit malloc_footprint_limit
+#define dlmalloc_set_footprint_limit malloc_set_footprint_limit
+#define dlmalloc_inspect_all malloc_inspect_all
+#define dlindependent_calloc independent_calloc
+#define dlindependent_comalloc independent_comalloc
+#define dlbulk_free bulk_free
+#endif /* USE_DL_PREFIX */
+
+/*
+ malloc(size_t n)
+ Returns a pointer to a newly allocated chunk of at least n bytes, or
+ null if no space is available, in which case errno is set to ENOMEM
+ on ANSI C systems.
+
+ If n is zero, malloc returns a minimum-sized chunk. (The minimum
+ size is 16 bytes on most 32bit systems, and 32 bytes on 64bit
+ systems.) Note that size_t is an unsigned type, so calls with
+ arguments that would be negative if signed are interpreted as
+ requests for huge amounts of space, which will often fail. The
+ maximum supported value of n differs across systems, but is in all
+ cases less than the maximum representable value of a size_t.
+*/
+DLMALLOC_EXPORT void* dlmalloc(size_t);
+
+/*
+ free(void* p)
+ Releases the chunk of memory pointed to by p, that had been previously
+ allocated using malloc or a related routine such as realloc.
+ It has no effect if p is null. If p was not malloced or already
+ freed, free(p) will by default cause the current program to abort.
+*/
+DLMALLOC_EXPORT void dlfree(void*);
+
+/*
+ calloc(size_t n_elements, size_t element_size);
+ Returns a pointer to n_elements * element_size bytes, with all locations
+ set to zero.
+*/
+DLMALLOC_EXPORT void* dlcalloc(size_t, size_t);
+
+/*
+ realloc(void* p, size_t n)
+ Returns a pointer to a chunk of size n that contains the same data
+ as does chunk p up to the minimum of (n, p's size) bytes, or null
+ if no space is available.
+
+ The returned pointer may or may not be the same as p. The algorithm
+ prefers extending p in most cases when possible, otherwise it
+ employs the equivalent of a malloc-copy-free sequence.
+
+ If p is null, realloc is equivalent to malloc.
+
+ If space is not available, realloc returns null, errno is set (if on
+ ANSI) and p is NOT freed.
+
+ if n is for fewer bytes than already held by p, the newly unused
+ space is lopped off and freed if possible. realloc with a size
+ argument of zero (re)allocates a minimum-sized chunk.
+
+ The old unix realloc convention of allowing the last-free'd chunk
+ to be used as an argument to realloc is not supported.
+*/
+DLMALLOC_EXPORT void* dlrealloc(void*, size_t);
+
+/*
+ realloc_in_place(void* p, size_t n)
+ Resizes the space allocated for p to size n, only if this can be
+ done without moving p (i.e., only if there is adjacent space
+ available if n is greater than p's current allocated size, or n is
+ less than or equal to p's size). This may be used instead of plain
+ realloc if an alternative allocation strategy is needed upon failure
+ to expand space; for example, reallocation of a buffer that must be
+ memory-aligned or cleared. You can use realloc_in_place to trigger
+ these alternatives only when needed.
+
+ Returns p if successful; otherwise null.
+*/
+DLMALLOC_EXPORT void* dlrealloc_in_place(void*, size_t);
+
+/*
+ memalign(size_t alignment, size_t n);
+ Returns a pointer to a newly allocated chunk of n bytes, aligned
+ in accord with the alignment argument.
+
+ The alignment argument should be a power of two. If the argument is
+ not a power of two, the nearest greater power is used.
+ 8-byte alignment is guaranteed by normal malloc calls, so don't
+ bother calling memalign with an argument of 8 or less.
+
+ Overreliance on memalign is a sure way to fragment space.
+*/
+DLMALLOC_EXPORT void* dlmemalign(size_t, size_t);
+
+/*
+ int posix_memalign(void** pp, size_t alignment, size_t n);
+ Allocates a chunk of n bytes, aligned in accord with the alignment
+ argument. Differs from memalign only in that it (1) assigns the
+ allocated memory to *pp rather than returning it, (2) fails and
+ returns EINVAL if the alignment is not a power of two (3) fails and
+ returns ENOMEM if memory cannot be allocated.
+*/
+DLMALLOC_EXPORT int dlposix_memalign(void**, size_t, size_t);
+
+/*
+ valloc(size_t n);
+ Equivalent to memalign(pagesize, n), where pagesize is the page
+ size of the system. If the pagesize is unknown, 4096 is used.
+*/
+DLMALLOC_EXPORT void* dlvalloc(size_t);
+
+/*
+ mallopt(int parameter_number, int parameter_value)
+ Sets tunable parameters The format is to provide a
+ (parameter-number, parameter-value) pair. mallopt then sets the
+ corresponding parameter to the argument value if it can (i.e., so
+ long as the value is meaningful), and returns 1 if successful else
+ 0. To workaround the fact that mallopt is specified to use int,
+ not size_t parameters, the value -1 is specially treated as the
+ maximum unsigned size_t value.
+
+ SVID/XPG/ANSI defines four standard param numbers for mallopt,
+ normally defined in malloc.h. None of these are use in this malloc,
+ so setting them has no effect. But this malloc also supports other
+ options in mallopt. See below for details. Briefly, supported
+ parameters are as follows (listed defaults are for "typical"
+ configurations).
+
+ Symbol param # default allowed param values
+ M_TRIM_THRESHOLD -1 2*1024*1024 any (-1 disables)
+ M_GRANULARITY -2 page size any power of 2 >= page size
+ M_MMAP_THRESHOLD -3 256*1024 any (or 0 if no MMAP support)
+*/
+DLMALLOC_EXPORT int dlmallopt(int, int);
+
+/*
+ malloc_footprint();
+ Returns the number of bytes obtained from the system. The total
+ number of bytes allocated by malloc, realloc etc., is less than this
+ value. Unlike mallinfo, this function returns only a precomputed
+ result, so can be called frequently to monitor memory consumption.
+ Even if locks are otherwise defined, this function does not use them,
+ so results might not be up to date.
+*/
+DLMALLOC_EXPORT size_t dlmalloc_footprint(void);
+
+/*
+ malloc_max_footprint();
+ Returns the maximum number of bytes obtained from the system. This
+ value will be greater than current footprint if deallocated space
+ has been reclaimed by the system. The peak number of bytes allocated
+ by malloc, realloc etc., is less than this value. Unlike mallinfo,
+ this function returns only a precomputed result, so can be called
+ frequently to monitor memory consumption. Even if locks are
+ otherwise defined, this function does not use them, so results might
+ not be up to date.
+*/
+DLMALLOC_EXPORT size_t dlmalloc_max_footprint(void);
+
+/*
+ malloc_footprint_limit();
+ Returns the number of bytes that the heap is allowed to obtain from
+ the system, returning the last value returned by
+ malloc_set_footprint_limit, or the maximum size_t value if
+ never set. The returned value reflects a permission. There is no
+ guarantee that this number of bytes can actually be obtained from
+ the system.
+*/
+DLMALLOC_EXPORT size_t dlmalloc_footprint_limit();
+
+/*
+ malloc_set_footprint_limit();
+ Sets the maximum number of bytes to obtain from the system, causing
+ failure returns from malloc and related functions upon attempts to
+ exceed this value. The argument value may be subject to page
+ rounding to an enforceable limit; this actual value is returned.
+ Using an argument of the maximum possible size_t effectively
+ disables checks. If the argument is less than or equal to the
+ current malloc_footprint, then all future allocations that require
+ additional system memory will fail. However, invocation cannot
+ retroactively deallocate existing used memory.
+*/
+DLMALLOC_EXPORT size_t dlmalloc_set_footprint_limit(size_t bytes);
+
+#if MALLOC_INSPECT_ALL
+/*
+ malloc_inspect_all(void(*handler)(void *start,
+ void *end,
+ size_t used_bytes,
+ void* callback_arg),
+ void* arg);
+ Traverses the heap and calls the given handler for each managed
+ region, skipping all bytes that are (or may be) used for bookkeeping
+ purposes. Traversal does not include include chunks that have been
+ directly memory mapped. Each reported region begins at the start
+ address, and continues up to but not including the end address. The
+ first used_bytes of the region contain allocated data. If
+ used_bytes is zero, the region is unallocated. The handler is
+ invoked with the given callback argument. If locks are defined, they
+ are held during the entire traversal. It is a bad idea to invoke
+ other malloc functions from within the handler.
+
+ For example, to count the number of in-use chunks with size greater
+ than 1000, you could write:
+ static int count = 0;
+ void count_chunks(void* start, void* end, size_t used, void* arg) {
+ if (used >= 1000) ++count;
+ }
+ then:
+ malloc_inspect_all(count_chunks, NULL);
+
+ malloc_inspect_all is compiled only if MALLOC_INSPECT_ALL is defined.
+*/
+DLMALLOC_EXPORT void dlmalloc_inspect_all(void(*handler)(void*, void *, size_t, void*),
+ void* arg);
+
+#endif /* MALLOC_INSPECT_ALL */
+
+#if !NO_MALLINFO
+/*
+ mallinfo()
+ Returns (by copy) a struct containing various summary statistics:
+
+ arena: current total non-mmapped bytes allocated from system
+ ordblks: the number of free chunks
+ smblks: always zero.
+ hblks: current number of mmapped regions
+ hblkhd: total bytes held in mmapped regions
+ usmblks: the maximum total allocated space. This will be greater
+ than current total if trimming has occurred.
+ fsmblks: always zero
+ uordblks: current total allocated space (normal or mmapped)
+ fordblks: total free space
+ keepcost: the maximum number of bytes that could ideally be released
+ back to system via malloc_trim. ("ideally" means that
+ it ignores page restrictions etc.)
+
+ Because these fields are ints, but internal bookkeeping may
+ be kept as longs, the reported values may wrap around zero and
+ thus be inaccurate.
+*/
+DLMALLOC_EXPORT struct mallinfo dlmallinfo(void);
+#endif /* NO_MALLINFO */
+
+/*
+ independent_calloc(size_t n_elements, size_t element_size, void* chunks[]);
+
+ independent_calloc is similar to calloc, but instead of returning a
+ single cleared space, it returns an array of pointers to n_elements
+ independent elements that can hold contents of size elem_size, each
+ of which starts out cleared, and can be independently freed,
+ realloc'ed etc. The elements are guaranteed to be adjacently
+ allocated (this is not guaranteed to occur with multiple callocs or
+ mallocs), which may also improve cache locality in some
+ applications.
+
+ The "chunks" argument is optional (i.e., may be null, which is
+ probably the most typical usage). If it is null, the returned array
+ is itself dynamically allocated and should also be freed when it is
+ no longer needed. Otherwise, the chunks array must be of at least
+ n_elements in length. It is filled in with the pointers to the
+ chunks.
+
+ In either case, independent_calloc returns this pointer array, or
+ null if the allocation failed. If n_elements is zero and "chunks"
+ is null, it returns a chunk representing an array with zero elements
+ (which should be freed if not wanted).
+
+ Each element must be freed when it is no longer needed. This can be
+ done all at once using bulk_free.
+
+ independent_calloc simplifies and speeds up implementations of many
+ kinds of pools. It may also be useful when constructing large data
+ structures that initially have a fixed number of fixed-sized nodes,
+ but the number is not known at compile time, and some of the nodes
+ may later need to be freed. For example:
+
+ struct Node { int item; struct Node* next; };
+
+ struct Node* build_list() {
+ struct Node** pool;
+ int n = read_number_of_nodes_needed();
+ if (n <= 0) return 0;
+ pool = (struct Node**)(independent_calloc(n, sizeof(struct Node), 0);
+ if (pool == 0) die();
+ // organize into a linked list...
+ struct Node* first = pool[0];
+ for (i = 0; i < n-1; ++i)
+ pool[i]->next = pool[i+1];
+ free(pool); // Can now free the array (or not, if it is needed later)
+ return first;
+ }
+*/
+DLMALLOC_EXPORT void** dlindependent_calloc(size_t, size_t, void**);
+
+/*
+ independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]);
+
+ independent_comalloc allocates, all at once, a set of n_elements
+ chunks with sizes indicated in the "sizes" array. It returns
+ an array of pointers to these elements, each of which can be
+ independently freed, realloc'ed etc. The elements are guaranteed to
+ be adjacently allocated (this is not guaranteed to occur with
+ multiple callocs or mallocs), which may also improve cache locality
+ in some applications.
+
+ The "chunks" argument is optional (i.e., may be null). If it is null
+ the returned array is itself dynamically allocated and should also
+ be freed when it is no longer needed. Otherwise, the chunks array
+ must be of at least n_elements in length. It is filled in with the
+ pointers to the chunks.
+
+ In either case, independent_comalloc returns this pointer array, or
+ null if the allocation failed. If n_elements is zero and chunks is
+ null, it returns a chunk representing an array with zero elements
+ (which should be freed if not wanted).
+
+ Each element must be freed when it is no longer needed. This can be
+ done all at once using bulk_free.
+
+ independent_comallac differs from independent_calloc in that each
+ element may have a different size, and also that it does not
+ automatically clear elements.
+
+ independent_comalloc can be used to speed up allocation in cases
+ where several structs or objects must always be allocated at the
+ same time. For example:
+
+ struct Head { ... }
+ struct Foot { ... }
+
+ void send_message(char* msg) {
+ int msglen = strlen(msg);
+ size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };
+ void* chunks[3];
+ if (independent_comalloc(3, sizes, chunks) == 0)
+ die();
+ struct Head* head = (struct Head*)(chunks[0]);
+ char* body = (char*)(chunks[1]);
+ struct Foot* foot = (struct Foot*)(chunks[2]);
+ // ...
+ }
+
+ In general though, independent_comalloc is worth using only for
+ larger values of n_elements. For small values, you probably won't
+ detect enough difference from series of malloc calls to bother.
+
+ Overuse of independent_comalloc can increase overall memory usage,
+ since it cannot reuse existing noncontiguous small chunks that
+ might be available for some of the elements.
+*/
+DLMALLOC_EXPORT void** dlindependent_comalloc(size_t, size_t*, void**);
+
+/*
+ bulk_free(void* array[], size_t n_elements)
+ Frees and clears (sets to null) each non-null pointer in the given
+ array. This is likely to be faster than freeing them one-by-one.
+ If footers are used, pointers that have been allocated in different
+ mspaces are not freed or cleared, and the count of all such pointers
+ is returned. For large arrays of pointers with poor locality, it
+ may be worthwhile to sort this array before calling bulk_free.
+*/
+DLMALLOC_EXPORT size_t dlbulk_free(void**, size_t n_elements);
+
+/*
+ pvalloc(size_t n);
+ Equivalent to valloc(minimum-page-that-holds(n)), that is,
+ round up n to nearest pagesize.
+ */
+DLMALLOC_EXPORT void* dlpvalloc(size_t);
+
+/*
+ malloc_trim(size_t pad);
+
+ If possible, gives memory back to the system (via negative arguments
+ to sbrk) if there is unused memory at the `high' end of the malloc
+ pool or in unused MMAP segments. You can call this after freeing
+ large blocks of memory to potentially reduce the system-level memory
+ requirements of a program. However, it cannot guarantee to reduce
+ memory. Under some allocation patterns, some large free blocks of
+ memory will be locked between two used chunks, so they cannot be
+ given back to the system.
+
+ The `pad' argument to malloc_trim represents the amount of free
+ trailing space to leave untrimmed. If this argument is zero, only
+ the minimum amount of memory to maintain internal data structures
+ will be left. Non-zero arguments can be supplied to maintain enough
+ trailing space to service future expected allocations without having
+ to re-obtain memory from the system.
+
+ Malloc_trim returns 1 if it actually released any memory, else 0.
+*/
+DLMALLOC_EXPORT int dlmalloc_trim(size_t);
+
+/*
+ malloc_stats();
+ Prints on stderr the amount of space obtained from the system (both
+ via sbrk and mmap), the maximum amount (which may be more than
+ current if malloc_trim and/or munmap got called), and the current
+ number of bytes allocated via malloc (or realloc, etc) but not yet
+ freed. Note that this is the number of bytes allocated, not the
+ number requested. It will be larger than the number requested
+ because of alignment and bookkeeping overhead. Because it includes
+ alignment wastage as being in use, this figure may be greater than
+ zero even when no user-level chunks are allocated.
+
+ The reported current and maximum system memory can be inaccurate if
+ a program makes other calls to system memory allocation functions
+ (normally sbrk) outside of malloc.
+
+ malloc_stats prints only the most commonly interesting statistics.
+ More information can be obtained by calling mallinfo.
+*/
+DLMALLOC_EXPORT void dlmalloc_stats(void);
+
+#endif /* ONLY_MSPACES */
+
+/*
+ malloc_usable_size(void* p);
+
+ Returns the number of bytes you can actually use in
+ an allocated chunk, which may be more than you requested (although
+ often not) due to alignment and minimum size constraints.
+ You can use this many bytes without worrying about
+ overwriting other allocated objects. This is not a particularly great
+ programming practice. malloc_usable_size can be more useful in
+ debugging and assertions, for example:
+
+ p = malloc(n);
+ assert(malloc_usable_size(p) >= 256);
+*/
+size_t dlmalloc_usable_size(void*);
+
+#if MSPACES
+
+/*
+ mspace is an opaque type representing an independent
+ region of space that supports mspace_malloc, etc.
+*/
+typedef void* mspace;
+
+/*
+ create_mspace creates and returns a new independent space with the
+ given initial capacity, or, if 0, the default granularity size. It
+ returns null if there is no system memory available to create the
+ space. If argument locked is non-zero, the space uses a separate
+ lock to control access. The capacity of the space will grow
+ dynamically as needed to service mspace_malloc requests. You can
+ control the sizes of incremental increases of this space by
+ compiling with a different DEFAULT_GRANULARITY or dynamically
+ setting with mallopt(M_GRANULARITY, value).
+*/
+DLMALLOC_EXPORT mspace create_mspace(size_t capacity, int locked);
+
+/*
+ destroy_mspace destroys the given space, and attempts to return all
+ of its memory back to the system, returning the total number of
+ bytes freed. After destruction, the results of access to all memory
+ used by the space become undefined.
+*/
+DLMALLOC_EXPORT size_t destroy_mspace(mspace msp);
+
+/*
+ create_mspace_with_base uses the memory supplied as the initial base
+ of a new mspace. Part (less than 128*sizeof(size_t) bytes) of this
+ space is used for bookkeeping, so the capacity must be at least this
+ large. (Otherwise 0 is returned.) When this initial space is
+ exhausted, additional memory will be obtained from the system.
+ Destroying this space will deallocate all additionally allocated
+ space (if possible) but not the initial base.
+*/
+DLMALLOC_EXPORT mspace create_mspace_with_base(void* base, size_t capacity, int locked);
+
+/*
+ mspace_track_large_chunks controls whether requests for large chunks
+ are allocated in their own untracked mmapped regions, separate from
+ others in this mspace. By default large chunks are not tracked,
+ which reduces fragmentation. However, such chunks are not
+ necessarily released to the system upon destroy_mspace. Enabling
+ tracking by setting to true may increase fragmentation, but avoids
+ leakage when relying on destroy_mspace to release all memory
+ allocated using this space. The function returns the previous
+ setting.
+*/
+DLMALLOC_EXPORT int mspace_track_large_chunks(mspace msp, int enable);
+
+
+/*
+ mspace_malloc behaves as malloc, but operates within
+ the given space.
+*/
+DLMALLOC_EXPORT void* mspace_malloc(mspace msp, size_t bytes);
+
+/*
+ mspace_free behaves as free, but operates within
+ the given space.
+
+ If compiled with FOOTERS==1, mspace_free is not actually needed.
+ free may be called instead of mspace_free because freed chunks from
+ any space are handled by their originating spaces.
+*/
+DLMALLOC_EXPORT void mspace_free(mspace msp, void* mem);
+
+/*
+ mspace_realloc behaves as realloc, but operates within
+ the given space.
+
+ If compiled with FOOTERS==1, mspace_realloc is not actually
+ needed. realloc may be called instead of mspace_realloc because
+ realloced chunks from any space are handled by their originating
+ spaces.
+*/
+DLMALLOC_EXPORT void* mspace_realloc(mspace msp, void* mem, size_t newsize);
+
+/*
+ mspace_calloc behaves as calloc, but operates within
+ the given space.
+*/
+DLMALLOC_EXPORT void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size);
+
+/*
+ mspace_memalign behaves as memalign, but operates within
+ the given space.
+*/
+DLMALLOC_EXPORT void* mspace_memalign(mspace msp, size_t alignment, size_t bytes);
+
+/*
+ mspace_independent_calloc behaves as independent_calloc, but
+ operates within the given space.
+*/
+DLMALLOC_EXPORT void** mspace_independent_calloc(mspace msp, size_t n_elements,
+ size_t elem_size, void* chunks[]);
+
+/*
+ mspace_independent_comalloc behaves as independent_comalloc, but
+ operates within the given space.
+*/
+DLMALLOC_EXPORT void** mspace_independent_comalloc(mspace msp, size_t n_elements,
+ size_t sizes[], void* chunks[]);
+
+/*
+ mspace_footprint() returns the number of bytes obtained from the
+ system for this space.
+*/
+DLMALLOC_EXPORT size_t mspace_footprint(mspace msp);
+
+/*
+ mspace_max_footprint() returns the peak number of bytes obtained from the
+ system for this space.
+*/
+DLMALLOC_EXPORT size_t mspace_max_footprint(mspace msp);
+
+
+#if !NO_MALLINFO
+/*
+ mspace_mallinfo behaves as mallinfo, but reports properties of
+ the given space.
+*/
+DLMALLOC_EXPORT struct mallinfo mspace_mallinfo(mspace msp);
+#endif /* NO_MALLINFO */
+
+/*
+ malloc_usable_size(void* p) behaves the same as malloc_usable_size;
+*/
+DLMALLOC_EXPORT size_t mspace_usable_size(void* mem);
+
+/*
+ mspace_malloc_stats behaves as malloc_stats, but reports
+ properties of the given space.
+*/
+DLMALLOC_EXPORT void mspace_malloc_stats(mspace msp);
+
+/*
+ mspace_trim behaves as malloc_trim, but
+ operates within the given space.
+*/
+DLMALLOC_EXPORT int mspace_trim(mspace msp, size_t pad);
+
+/*
+ An alias for mallopt.
+*/
+DLMALLOC_EXPORT int mspace_mallopt(int, int);
+
+#endif /* MSPACES */
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif /* __cplusplus */
+
+/*
+ ========================================================================
+ To make a fully customizable malloc.h header file, cut everything
+ above this line, put into file malloc.h, edit to suit, and #include it
+ on the next line, as well as in programs that use this malloc.
+ ========================================================================
+*/
+
+/* #include "malloc.h" */
+
+/*------------------------------ internal #includes ---------------------- */
+
+#ifdef _MSC_VER
+#pragma warning( disable : 4146 ) /* no "unsigned" warnings */
+#endif /* _MSC_VER */
+#if !NO_MALLOC_STATS
+#include <stdio.h> /* for printing in malloc_stats */
+#endif /* NO_MALLOC_STATS */
+#ifndef LACKS_ERRNO_H
+#include <errno.h> /* for MALLOC_FAILURE_ACTION */
+#endif /* LACKS_ERRNO_H */
+#ifdef DEBUG
+#if ABORT_ON_ASSERT_FAILURE
+#undef assert
+#define assert(x) if(!(x)) ABORT
+#else /* ABORT_ON_ASSERT_FAILURE */
+#include <assert.h>
+#endif /* ABORT_ON_ASSERT_FAILURE */
+#else /* DEBUG */
+#ifndef assert
+#define assert(x)
+#endif
+#define DEBUG 0
+#endif /* DEBUG */
+#if !defined(WIN32) && !defined(LACKS_TIME_H)
+#include <time.h> /* for magic initialization */
+#endif /* WIN32 */
+#ifndef LACKS_STDLIB_H
+#include <stdlib.h> /* for abort() */
+#endif /* LACKS_STDLIB_H */
+#ifndef LACKS_STRING_H
+#include <string.h> /* for memset etc */
+#endif /* LACKS_STRING_H */
+#if USE_BUILTIN_FFS
+#ifndef LACKS_STRINGS_H
+#include <strings.h> /* for ffs */
+#endif /* LACKS_STRINGS_H */
+#endif /* USE_BUILTIN_FFS */
+#if HAVE_MMAP
+#ifndef LACKS_SYS_MMAN_H
+/* On some versions of linux, mremap decl in mman.h needs __USE_GNU set */
+#if (defined(linux) && !defined(__USE_GNU))
+#define __USE_GNU 1
+#include <sys/mman.h> /* for mmap */
+#undef __USE_GNU
+#else
+#include <sys/mman.h> /* for mmap */
+#endif /* linux */
+#endif /* LACKS_SYS_MMAN_H */
+#ifndef LACKS_FCNTL_H
+#include <fcntl.h>
+#endif /* LACKS_FCNTL_H */
+#endif /* HAVE_MMAP */
+#ifndef LACKS_UNISTD_H
+#include <unistd.h> /* for sbrk, sysconf */
+#else /* LACKS_UNISTD_H */
+#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)
+extern void* sbrk(ptrdiff_t);
+#endif /* FreeBSD etc */
+#endif /* LACKS_UNISTD_H */
+
+/* Declarations for locking */
+#if USE_LOCKS
+#ifndef WIN32
+#if defined (__SVR4) && defined (__sun) /* solaris */
+#include <thread.h>
+#elif !defined(LACKS_SCHED_H)
+#include <sched.h>
+#endif /* solaris or LACKS_SCHED_H */
+#if (defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0) || !USE_SPIN_LOCKS
+#include <pthread.h>
+#endif /* USE_RECURSIVE_LOCKS ... */
+#elif defined(_MSC_VER)
+#ifndef _M_AMD64
+/* These are already defined on AMD64 builds */
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+LONG __cdecl _InterlockedCompareExchange(LONG volatile *Dest, LONG Exchange, LONG Comp);
+LONG __cdecl _InterlockedExchange(LONG volatile *Target, LONG Value);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* _M_AMD64 */
+#pragma intrinsic (_InterlockedCompareExchange)
+#pragma intrinsic (_InterlockedExchange)
+#define interlockedcompareexchange _InterlockedCompareExchange
+#define interlockedexchange _InterlockedExchange
+#elif defined(WIN32) && defined(__GNUC__)
+#define interlockedcompareexchange(a, b, c) __sync_val_compare_and_swap(a, c, b)
+#define interlockedexchange __sync_lock_test_and_set
+#endif /* Win32 */
+#endif /* USE_LOCKS */
+
+/* Declarations for bit scanning on win32 */
+#if defined(_MSC_VER) && _MSC_VER>=1300
+#ifndef BitScanForward /* Try to avoid pulling in WinNT.h */
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+unsigned char _BitScanForward(unsigned long *index, unsigned long mask);
+unsigned char _BitScanReverse(unsigned long *index, unsigned long mask);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#define BitScanForward _BitScanForward
+#define BitScanReverse _BitScanReverse
+#pragma intrinsic(_BitScanForward)
+#pragma intrinsic(_BitScanReverse)
+#endif /* BitScanForward */
+#endif /* defined(_MSC_VER) && _MSC_VER>=1300 */
+
+#ifndef WIN32
+#ifndef malloc_getpagesize
+# ifdef _SC_PAGESIZE /* some SVR4 systems omit an underscore */
+# ifndef _SC_PAGE_SIZE
+# define _SC_PAGE_SIZE _SC_PAGESIZE
+# endif
+# endif
+# ifdef _SC_PAGE_SIZE
+# define malloc_getpagesize sysconf(_SC_PAGE_SIZE)
+# else
+# if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE)
+ extern size_t getpagesize();
+# define malloc_getpagesize getpagesize()
+# else
+# ifdef WIN32 /* use supplied emulation of getpagesize */
+# define malloc_getpagesize getpagesize()
+# else
+# ifndef LACKS_SYS_PARAM_H
+# include <sys/param.h>
+# endif
+# ifdef EXEC_PAGESIZE
+# define malloc_getpagesize EXEC_PAGESIZE
+# else
+# ifdef NBPG
+# ifndef CLSIZE
+# define malloc_getpagesize NBPG
+# else
+# define malloc_getpagesize (NBPG * CLSIZE)
+# endif
+# else
+# ifdef NBPC
+# define malloc_getpagesize NBPC
+# else
+# ifdef PAGESIZE
+# define malloc_getpagesize PAGESIZE
+# else /* just guess */
+# define malloc_getpagesize ((size_t)4096U)
+# endif
+# endif
+# endif
+# endif
+# endif
+# endif
+# endif
+#endif
+#endif
+
+/* ------------------- size_t and alignment properties -------------------- */
+
+/* The byte and bit size of a size_t */
+#define SIZE_T_SIZE (sizeof(size_t))
+#define SIZE_T_BITSIZE (sizeof(size_t) << 3)
+
+/* Some constants coerced to size_t */
+/* Annoying but necessary to avoid errors on some platforms */
+#define SIZE_T_ZERO ((size_t)0)
+#define SIZE_T_ONE ((size_t)1)
+#define SIZE_T_TWO ((size_t)2)
+#define SIZE_T_FOUR ((size_t)4)
+#define TWO_SIZE_T_SIZES (SIZE_T_SIZE<<1)
+#define FOUR_SIZE_T_SIZES (SIZE_T_SIZE<<2)
+#define SIX_SIZE_T_SIZES (FOUR_SIZE_T_SIZES+TWO_SIZE_T_SIZES)
+#define HALF_MAX_SIZE_T (MAX_SIZE_T / 2U)
+
+/* The bit mask value corresponding to MALLOC_ALIGNMENT */
+#define CHUNK_ALIGN_MASK (MALLOC_ALIGNMENT - SIZE_T_ONE)
+
+/* True if address a has acceptable alignment */
+#define is_aligned(A) (((size_t)((A)) & (CHUNK_ALIGN_MASK)) == 0)
+
+/* the number of bytes to offset an address to align it */
+#define align_offset(A)\
+ ((((size_t)(A) & CHUNK_ALIGN_MASK) == 0)? 0 :\
+ ((MALLOC_ALIGNMENT - ((size_t)(A) & CHUNK_ALIGN_MASK)) & CHUNK_ALIGN_MASK))
+
+/* -------------------------- MMAP preliminaries ------------------------- */
+
+/*
+ If HAVE_MORECORE or HAVE_MMAP are false, we just define calls and
+ checks to fail so compiler optimizer can delete code rather than
+ using so many "#if"s.
+*/
+
+
+/* MORECORE and MMAP must return MFAIL on failure */
+#define MFAIL ((void*)(MAX_SIZE_T))
+#define CMFAIL ((char*)(MFAIL)) /* defined for convenience */
+
+#if HAVE_MMAP
+
+#ifndef WIN32
+#define MUNMAP_DEFAULT(a, s) munmap((a), (s))
+#define MMAP_PROT (PROT_READ|PROT_WRITE)
+#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
+#define MAP_ANONYMOUS MAP_ANON
+#endif /* MAP_ANON */
+#ifdef MAP_ANONYMOUS
+#define MMAP_FLAGS (MAP_PRIVATE|MAP_ANONYMOUS)
+#define MMAP_DEFAULT(s) mmap(0, (s), MMAP_PROT, MMAP_FLAGS, -1, 0)
+#else /* MAP_ANONYMOUS */
+/*
+ Nearly all versions of mmap support MAP_ANONYMOUS, so the following
+ is unlikely to be needed, but is supplied just in case.
+*/
+#define MMAP_FLAGS (MAP_PRIVATE)
+static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
+#define MMAP_DEFAULT(s) ((dev_zero_fd < 0) ? \
+ (dev_zero_fd = open("/dev/zero", O_RDWR), \
+ mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) : \
+ mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0))
+#endif /* MAP_ANONYMOUS */
+
+#define DIRECT_MMAP_DEFAULT(s) MMAP_DEFAULT(s)
+
+#else /* WIN32 */
+
+/* Win32 MMAP via VirtualAlloc */
+static FORCEINLINE void* win32mmap(size_t size) {
+ void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
+ return (ptr != 0)? ptr: MFAIL;
+}
+
+/* For direct MMAP, use MEM_TOP_DOWN to minimize interference */
+static FORCEINLINE void* win32direct_mmap(size_t size) {
+ void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT|MEM_TOP_DOWN,
+ PAGE_READWRITE);
+ return (ptr != 0)? ptr: MFAIL;
+}
+
+/* This function supports releasing coalesed segments */
+static FORCEINLINE int win32munmap(void* ptr, size_t size) {
+ MEMORY_BASIC_INFORMATION minfo;
+ char* cptr = (char*)ptr;
+ while (size) {
+ if (VirtualQuery(cptr, &minfo, sizeof(minfo)) == 0)
+ return -1;
+ if (minfo.BaseAddress != cptr || minfo.AllocationBase != cptr ||
+ minfo.State != MEM_COMMIT || minfo.RegionSize > size)
+ return -1;
+ if (VirtualFree(cptr, 0, MEM_RELEASE) == 0)
+ return -1;
+ cptr += minfo.RegionSize;
+ size -= minfo.RegionSize;
+ }
+ return 0;
+}
+
+#define MMAP_DEFAULT(s) win32mmap(s)
+#define MUNMAP_DEFAULT(a, s) win32munmap((a), (s))
+#define DIRECT_MMAP_DEFAULT(s) win32direct_mmap(s)
+#endif /* WIN32 */
+#endif /* HAVE_MMAP */
+
+#if HAVE_MREMAP
+#ifndef WIN32
+#define MREMAP_DEFAULT(addr, osz, nsz, mv) mremap((addr), (osz), (nsz), (mv))
+#endif /* WIN32 */
+#endif /* HAVE_MREMAP */
+
+/**
+ * Define CALL_MORECORE
+ */
+#if HAVE_MORECORE
+ #ifdef MORECORE
+ #define CALL_MORECORE(S) MORECORE(S)
+ #else /* MORECORE */
+ #define CALL_MORECORE(S) MORECORE_DEFAULT(S)
+ #endif /* MORECORE */
+#else /* HAVE_MORECORE */
+ #define CALL_MORECORE(S) MFAIL
+#endif /* HAVE_MORECORE */
+
+/**
+ * Define CALL_MMAP/CALL_MUNMAP/CALL_DIRECT_MMAP
+ */
+#if HAVE_MMAP
+ #define USE_MMAP_BIT (SIZE_T_ONE)
+
+ #ifdef MMAP
+ #define CALL_MMAP(s) MMAP(s)
+ #else /* MMAP */
+ #define CALL_MMAP(s) MMAP_DEFAULT(s)
+ #endif /* MMAP */
+ #ifdef MUNMAP
+ #define CALL_MUNMAP(a, s) MUNMAP((a), (s))
+ #else /* MUNMAP */
+ #define CALL_MUNMAP(a, s) MUNMAP_DEFAULT((a), (s))
+ #endif /* MUNMAP */
+ #ifdef DIRECT_MMAP
+ #define CALL_DIRECT_MMAP(s) DIRECT_MMAP(s)
+ #else /* DIRECT_MMAP */
+ #define CALL_DIRECT_MMAP(s) DIRECT_MMAP_DEFAULT(s)
+ #endif /* DIRECT_MMAP */
+#else /* HAVE_MMAP */
+ #define USE_MMAP_BIT (SIZE_T_ZERO)
+
+ #define MMAP(s) MFAIL
+ #define MUNMAP(a, s) (-1)
+ #define DIRECT_MMAP(s) MFAIL
+ #define CALL_DIRECT_MMAP(s) DIRECT_MMAP(s)
+ #define CALL_MMAP(s) MMAP(s)
+ #define CALL_MUNMAP(a, s) MUNMAP((a), (s))
+#endif /* HAVE_MMAP */
+
+/**
+ * Define CALL_MREMAP
+ */
+#if HAVE_MMAP && HAVE_MREMAP
+ #ifdef MREMAP
+ #define CALL_MREMAP(addr, osz, nsz, mv) MREMAP((addr), (osz), (nsz), (mv))
+ #else /* MREMAP */
+ #define CALL_MREMAP(addr, osz, nsz, mv) MREMAP_DEFAULT((addr), (osz), (nsz), (mv))
+ #endif /* MREMAP */
+#else /* HAVE_MMAP && HAVE_MREMAP */
+ #define CALL_MREMAP(addr, osz, nsz, mv) MFAIL
+#endif /* HAVE_MMAP && HAVE_MREMAP */
+
+/* mstate bit set if continguous morecore disabled or failed */
+#define USE_NONCONTIGUOUS_BIT (4U)
+
+/* segment bit set in create_mspace_with_base */
+#define EXTERN_BIT (8U)
+
+
+/* --------------------------- Lock preliminaries ------------------------ */
+
+/*
+ When locks are defined, there is one global lock, plus
+ one per-mspace lock.
+
+ The global lock_ensures that mparams.magic and other unique
+ mparams values are initialized only once. It also protects
+ sequences of calls to MORECORE. In many cases sys_alloc requires
+ two calls, that should not be interleaved with calls by other
+ threads. This does not protect against direct calls to MORECORE
+ by other threads not using this lock, so there is still code to
+ cope the best we can on interference.
+
+ Per-mspace locks surround calls to malloc, free, etc.
+ By default, locks are simple non-reentrant mutexes.
+
+ Because lock-protected regions generally have bounded times, it is
+ OK to use the supplied simple spinlocks. Spinlocks are likely to
+ improve performance for lightly contended applications, but worsen
+ performance under heavy contention.
+
+ If USE_LOCKS is > 1, the definitions of lock routines here are
+ bypassed, in which case you will need to define the type MLOCK_T,
+ and at least INITIAL_LOCK, DESTROY_LOCK, ACQUIRE_LOCK, RELEASE_LOCK
+ and TRY_LOCK. You must also declare a
+ static MLOCK_T malloc_global_mutex = { initialization values };.
+
+*/
+
+#if !USE_LOCKS
+#define USE_LOCK_BIT (0U)
+#define INITIAL_LOCK(l) (0)
+#define DESTROY_LOCK(l) (0)
+#define ACQUIRE_MALLOC_GLOBAL_LOCK()
+#define RELEASE_MALLOC_GLOBAL_LOCK()
+
+#else
+#if USE_LOCKS > 1
+/* ----------------------- User-defined locks ------------------------ */
+/* Define your own lock implementation here */
+/* #define INITIAL_LOCK(lk) ... */
+/* #define DESTROY_LOCK(lk) ... */
+/* #define ACQUIRE_LOCK(lk) ... */
+/* #define RELEASE_LOCK(lk) ... */
+/* #define TRY_LOCK(lk) ... */
+/* static MLOCK_T malloc_global_mutex = ... */
+
+#elif USE_SPIN_LOCKS
+
+/* First, define CAS_LOCK and CLEAR_LOCK on ints */
+/* Note CAS_LOCK defined to return 0 on success */
+
+#if defined(__GNUC__)&& (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1))
+#define CAS_LOCK(sl) __sync_lock_test_and_set(sl, 1)
+#define CLEAR_LOCK(sl) __sync_lock_release(sl)
+
+#elif (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)))
+/* Custom spin locks for older gcc on x86 */
+static FORCEINLINE int x86_cas_lock(int *sl) {
+ int ret;
+ int val = 1;
+ int cmp = 0;
+ __asm__ __volatile__ ("lock; cmpxchgl %1, %2"
+ : "=a" (ret)
+ : "r" (val), "m" (*(sl)), "0"(cmp)
+ : "memory", "cc");
+ return ret;
+}
+
+static FORCEINLINE void x86_clear_lock(int* sl) {
+ assert(*sl != 0);
+ int prev = 0;
+ int ret;
+ __asm__ __volatile__ ("lock; xchgl %0, %1"
+ : "=r" (ret)
+ : "m" (*(sl)), "0"(prev)
+ : "memory");
+}
+
+#define CAS_LOCK(sl) x86_cas_lock(sl)
+#define CLEAR_LOCK(sl) x86_clear_lock(sl)
+
+#else /* Win32 MSC */
+#define CAS_LOCK(sl) interlockedexchange(sl, 1)
+#define CLEAR_LOCK(sl) interlockedexchange (sl, 0)
+
+#endif /* ... gcc spins locks ... */
+
+/* How to yield for a spin lock */
+#define SPINS_PER_YIELD 63
+#if defined(_MSC_VER)
+#define SLEEP_EX_DURATION 50 /* delay for yield/sleep */
+#define SPIN_LOCK_YIELD SleepEx(SLEEP_EX_DURATION, FALSE)
+#elif defined (__SVR4) && defined (__sun) /* solaris */
+#define SPIN_LOCK_YIELD thr_yield();
+#elif !defined(LACKS_SCHED_H)
+#define SPIN_LOCK_YIELD sched_yield();
+#else
+#define SPIN_LOCK_YIELD
+#endif /* ... yield ... */
+
+#if !defined(USE_RECURSIVE_LOCKS) || USE_RECURSIVE_LOCKS == 0
+/* Plain spin locks use single word (embedded in malloc_states) */
+static int spin_acquire_lock(int *sl) {
+ int spins = 0;
+ while (*(volatile int *)sl != 0 || CAS_LOCK(sl)) {
+ if ((++spins & SPINS_PER_YIELD) == 0) {
+ SPIN_LOCK_YIELD;
+ }
+ }
+ return 0;
+}
+
+#define MLOCK_T int
+#define TRY_LOCK(sl) !CAS_LOCK(sl)
+#define RELEASE_LOCK(sl) CLEAR_LOCK(sl)
+#define ACQUIRE_LOCK(sl) (CAS_LOCK(sl)? spin_acquire_lock(sl) : 0)
+#define INITIAL_LOCK(sl) (*sl = 0)
+#define DESTROY_LOCK(sl) (0)
+static MLOCK_T malloc_global_mutex = 0;
+
+#else /* USE_RECURSIVE_LOCKS */
+/* types for lock owners */
+#ifdef WIN32
+#define THREAD_ID_T DWORD
+#define CURRENT_THREAD GetCurrentThreadId()
+#define EQ_OWNER(X,Y) ((X) == (Y))
+#else
+/*
+ Note: the following assume that pthread_t is a type that can be
+ initialized to (casted) zero. If this is not the case, you will need to
+ somehow redefine these or not use spin locks.
+*/
+#define THREAD_ID_T pthread_t
+#define CURRENT_THREAD pthread_self()
+#define EQ_OWNER(X,Y) pthread_equal(X, Y)
+#endif
+
+struct malloc_recursive_lock {
+ int sl;
+ unsigned int c;
+ THREAD_ID_T threadid;
+};
+
+#define MLOCK_T struct malloc_recursive_lock
+static MLOCK_T malloc_global_mutex = { 0, 0, (THREAD_ID_T)0};
+
+static FORCEINLINE void recursive_release_lock(MLOCK_T *lk) {
+ assert(lk->sl != 0);
+ if (--lk->c == 0) {
+ CLEAR_LOCK(&lk->sl);
+ }
+}
+
+static FORCEINLINE int recursive_acquire_lock(MLOCK_T *lk) {
+ THREAD_ID_T mythreadid = CURRENT_THREAD;
+ int spins = 0;
+ for (;;) {
+ if (*((volatile int *)(&lk->sl)) == 0) {
+ if (!CAS_LOCK(&lk->sl)) {
+ lk->threadid = mythreadid;
+ lk->c = 1;
+ return 0;
+ }
+ }
+ else if (EQ_OWNER(lk->threadid, mythreadid)) {
+ ++lk->c;
+ return 0;
+ }
+ if ((++spins & SPINS_PER_YIELD) == 0) {
+ SPIN_LOCK_YIELD;
+ }
+ }
+}
+
+static FORCEINLINE int recursive_try_lock(MLOCK_T *lk) {
+ THREAD_ID_T mythreadid = CURRENT_THREAD;
+ if (*((volatile int *)(&lk->sl)) == 0) {
+ if (!CAS_LOCK(&lk->sl)) {
+ lk->threadid = mythreadid;
+ lk->c = 1;
+ return 1;
+ }
+ }
+ else if (EQ_OWNER(lk->threadid, mythreadid)) {
+ ++lk->c;
+ return 1;
+ }
+ return 0;
+}
+
+#define RELEASE_LOCK(lk) recursive_release_lock(lk)
+#define TRY_LOCK(lk) recursive_try_lock(lk)
+#define ACQUIRE_LOCK(lk) recursive_acquire_lock(lk)
+#define INITIAL_LOCK(lk) ((lk)->threadid = (THREAD_ID_T)0, (lk)->sl = 0, (lk)->c = 0)
+#define DESTROY_LOCK(lk) (0)
+#endif /* USE_RECURSIVE_LOCKS */
+
+#elif defined(WIN32) /* Win32 critical sections */
+#define MLOCK_T CRITICAL_SECTION
+#define ACQUIRE_LOCK(lk) (EnterCriticalSection(lk), 0)
+#define RELEASE_LOCK(lk) LeaveCriticalSection(lk)
+#define TRY_LOCK(lk) TryEnterCriticalSection(lk)
+#define INITIAL_LOCK(lk) (!InitializeCriticalSectionAndSpinCount((lk), 0x80000000|4000))
+#define DESTROY_LOCK(lk) (DeleteCriticalSection(lk), 0)
+#define NEED_GLOBAL_LOCK_INIT
+
+static MLOCK_T malloc_global_mutex;
+static volatile long malloc_global_mutex_status;
+
+/* Use spin loop to initialize global lock */
+static void init_malloc_global_mutex() {
+ for (;;) {
+ long stat = malloc_global_mutex_status;
+ if (stat > 0)
+ return;
+ /* transition to < 0 while initializing, then to > 0) */
+ if (stat == 0 &&
+ interlockedcompareexchange(&malloc_global_mutex_status, -1, 0) == 0) {
+ InitializeCriticalSection(&malloc_global_mutex);
+ interlockedexchange(&malloc_global_mutex_status,1);
+ return;
+ }
+ SleepEx(0, FALSE);
+ }
+}
+
+#else /* pthreads-based locks */
+#define MLOCK_T pthread_mutex_t
+#define ACQUIRE_LOCK(lk) pthread_mutex_lock(lk)
+#define RELEASE_LOCK(lk) pthread_mutex_unlock(lk)
+#define TRY_LOCK(lk) (!pthread_mutex_trylock(lk))
+#define INITIAL_LOCK(lk) pthread_init_lock(lk)
+#define DESTROY_LOCK(lk) pthread_mutex_destroy(lk)
+
+#if defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0 && defined(linux) && !defined(PTHREAD_MUTEX_RECURSIVE)
+/* Cope with old-style linux recursive lock initialization by adding */
+/* skipped internal declaration from pthread.h */
+extern int pthread_mutexattr_setkind_np __P ((pthread_mutexattr_t *__attr,
+ int __kind));
+#define PTHREAD_MUTEX_RECURSIVE PTHREAD_MUTEX_RECURSIVE_NP
+#define pthread_mutexattr_settype(x,y) pthread_mutexattr_setkind_np(x,y)
+#endif /* USE_RECURSIVE_LOCKS ... */
+
+static MLOCK_T malloc_global_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static int pthread_init_lock (MLOCK_T *lk) {
+ pthread_mutexattr_t attr;
+ if (pthread_mutexattr_init(&attr)) return 1;
+#if defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0
+ if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)) return 1;
+#endif
+ if (pthread_mutex_init(lk, &attr)) return 1;
+ if (pthread_mutexattr_destroy(&attr)) return 1;
+ return 0;
+}
+
+#endif /* ... lock types ... */
+
+/* Common code for all lock types */
+#define USE_LOCK_BIT (2U)
+
+#ifndef ACQUIRE_MALLOC_GLOBAL_LOCK
+#define ACQUIRE_MALLOC_GLOBAL_LOCK() ACQUIRE_LOCK(&malloc_global_mutex);
+#endif
+
+#ifndef RELEASE_MALLOC_GLOBAL_LOCK
+#define RELEASE_MALLOC_GLOBAL_LOCK() RELEASE_LOCK(&malloc_global_mutex);
+#endif
+
+#endif /* USE_LOCKS */
+
+/* ----------------------- Chunk representations ------------------------ */
+
+/*
+ (The following includes lightly edited explanations by Colin Plumb.)
+
+ The malloc_chunk declaration below is misleading (but accurate and
+ necessary). It declares a "view" into memory allowing access to
+ necessary fields at known offsets from a given base.
+
+ Chunks of memory are maintained using a `boundary tag' method as
+ originally described by Knuth. (See the paper by Paul Wilson
+ ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a survey of such
+ techniques.) Sizes of free chunks are stored both in the front of
+ each chunk and at the end. This makes consolidating fragmented
+ chunks into bigger chunks fast. The head fields also hold bits
+ representing whether chunks are free or in use.
+
+ Here are some pictures to make it clearer. They are "exploded" to
+ show that the state of a chunk can be thought of as extending from
+ the high 31 bits of the head field of its header through the
+ prev_foot and PINUSE_BIT bit of the following chunk header.
+
+ A chunk that's in use looks like:
+
+ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Size of previous chunk (if P = 0) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |P|
+ | Size of this chunk 1| +-+
+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | |
+ +- -+
+ | |
+ +- -+
+ | :
+ +- size - sizeof(size_t) available payload bytes -+
+ : |
+ chunk-> +- -+
+ | |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |1|
+ | Size of next chunk (may or may not be in use) | +-+
+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ And if it's free, it looks like this:
+
+ chunk-> +- -+
+ | User payload (must be in use, or we would have merged!) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |P|
+ | Size of this chunk 0| +-+
+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Next pointer |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Prev pointer |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | :
+ +- size - sizeof(struct chunk) unused bytes -+
+ : |
+ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Size of this chunk |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |0|
+ | Size of next chunk (must be in use, or we would have merged)| +-+
+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | :
+ +- User payload -+
+ : |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ |0|
+ +-+
+ Note that since we always merge adjacent free chunks, the chunks
+ adjacent to a free chunk must be in use.
+
+ Given a pointer to a chunk (which can be derived trivially from the
+ payload pointer) we can, in O(1) time, find out whether the adjacent
+ chunks are free, and if so, unlink them from the lists that they
+ are on and merge them with the current chunk.
+
+ Chunks always begin on even word boundaries, so the mem portion
+ (which is returned to the user) is also on an even word boundary, and
+ thus at least double-word aligned.
+
+ The P (PINUSE_BIT) bit, stored in the unused low-order bit of the
+ chunk size (which is always a multiple of two words), is an in-use
+ bit for the *previous* chunk. If that bit is *clear*, then the
+ word before the current chunk size contains the previous chunk
+ size, and can be used to find the front of the previous chunk.
+ The very first chunk allocated always has this bit set, preventing
+ access to non-existent (or non-owned) memory. If pinuse is set for
+ any given chunk, then you CANNOT determine the size of the
+ previous chunk, and might even get a memory addressing fault when
+ trying to do so.
+
+ The C (CINUSE_BIT) bit, stored in the unused second-lowest bit of
+ the chunk size redundantly records whether the current chunk is
+ inuse (unless the chunk is mmapped). This redundancy enables usage
+ checks within free and realloc, and reduces indirection when freeing
+ and consolidating chunks.
+
+ Each freshly allocated chunk must have both cinuse and pinuse set.
+ That is, each allocated chunk borders either a previously allocated
+ and still in-use chunk, or the base of its memory arena. This is
+ ensured by making all allocations from the `lowest' part of any
+ found chunk. Further, no free chunk physically borders another one,
+ so each free chunk is known to be preceded and followed by either
+ inuse chunks or the ends of memory.
+
+ Note that the `foot' of the current chunk is actually represented
+ as the prev_foot of the NEXT chunk. This makes it easier to
+ deal with alignments etc but can be very confusing when trying
+ to extend or adapt this code.
+
+ The exceptions to all this are
+
+ 1. The special chunk `top' is the top-most available chunk (i.e.,
+ the one bordering the end of available memory). It is treated
+ specially. Top is never included in any bin, is used only if
+ no other chunk is available, and is released back to the
+ system if it is very large (see M_TRIM_THRESHOLD). In effect,
+ the top chunk is treated as larger (and thus less well
+ fitting) than any other available chunk. The top chunk
+ doesn't update its trailing size field since there is no next
+ contiguous chunk that would have to index off it. However,
+ space is still allocated for it (TOP_FOOT_SIZE) to enable
+ separation or merging when space is extended.
+
+ 3. Chunks allocated via mmap, have both cinuse and pinuse bits
+ cleared in their head fields. Because they are allocated
+ one-by-one, each must carry its own prev_foot field, which is
+ also used to hold the offset this chunk has within its mmapped
+ region, which is needed to preserve alignment. Each mmapped
+ chunk is trailed by the first two fields of a fake next-chunk
+ for sake of usage checks.
+
+*/
+
+struct malloc_chunk {
+ size_t prev_foot; /* Size of previous chunk (if free). */
+ size_t head; /* Size and inuse bits. */
+ struct malloc_chunk* fd; /* double links -- used only if free. */
+ struct malloc_chunk* bk;
+};
+
+typedef struct malloc_chunk mchunk;
+typedef struct malloc_chunk* mchunkptr;
+typedef struct malloc_chunk* sbinptr; /* The type of bins of chunks */
+typedef unsigned int bindex_t; /* Described below */
+typedef unsigned int binmap_t; /* Described below */
+typedef unsigned int flag_t; /* The type of various bit flag sets */
+
+/* ------------------- Chunks sizes and alignments ----------------------- */
+
+#define MCHUNK_SIZE (sizeof(mchunk))
+
+#if FOOTERS
+#define CHUNK_OVERHEAD (TWO_SIZE_T_SIZES)
+#else /* FOOTERS */
+#define CHUNK_OVERHEAD (SIZE_T_SIZE)
+#endif /* FOOTERS */
+
+/* MMapped chunks need a second word of overhead ... */
+#define MMAP_CHUNK_OVERHEAD (TWO_SIZE_T_SIZES)
+/* ... and additional padding for fake next-chunk at foot */
+#define MMAP_FOOT_PAD (FOUR_SIZE_T_SIZES)
+
+/* The smallest size we can malloc is an aligned minimal chunk */
+#define MIN_CHUNK_SIZE\
+ ((MCHUNK_SIZE + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)
+
+/* conversion from malloc headers to user pointers, and back */
+#define chunk2mem(p) ((void*)((char*)(p) + TWO_SIZE_T_SIZES))
+#define mem2chunk(mem) ((mchunkptr)((char*)(mem) - TWO_SIZE_T_SIZES))
+/* chunk associated with aligned address A */
+#define align_as_chunk(A) (mchunkptr)((A) + align_offset(chunk2mem(A)))
+
+/* Bounds on request (not chunk) sizes. */
+#define MAX_REQUEST ((-MIN_CHUNK_SIZE) << 2)
+#define MIN_REQUEST (MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE)
+
+/* pad request bytes into a usable size */
+#define pad_request(req) \
+ (((req) + CHUNK_OVERHEAD + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)
+
+/* pad request, checking for minimum (but not maximum) */
+#define request2size(req) \
+ (((req) < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(req))
+
+
+/* ------------------ Operations on head and foot fields ----------------- */
+
+/*
+ The head field of a chunk is or'ed with PINUSE_BIT when previous
+ adjacent chunk in use, and or'ed with CINUSE_BIT if this chunk is in
+ use, unless mmapped, in which case both bits are cleared.
+
+ FLAG4_BIT is not used by this malloc, but might be useful in extensions.
+*/
+
+#define PINUSE_BIT (SIZE_T_ONE)
+#define CINUSE_BIT (SIZE_T_TWO)
+#define FLAG4_BIT (SIZE_T_FOUR)
+#define INUSE_BITS (PINUSE_BIT|CINUSE_BIT)
+#define FLAG_BITS (PINUSE_BIT|CINUSE_BIT|FLAG4_BIT)
+
+/* Head value for fenceposts */
+#define FENCEPOST_HEAD (INUSE_BITS|SIZE_T_SIZE)
+
+/* extraction of fields from head words */
+#define cinuse(p) ((p)->head & CINUSE_BIT)
+#define pinuse(p) ((p)->head & PINUSE_BIT)
+#define flag4inuse(p) ((p)->head & FLAG4_BIT)
+#define is_inuse(p) (((p)->head & INUSE_BITS) != PINUSE_BIT)
+#define is_mmapped(p) (((p)->head & INUSE_BITS) == 0)
+
+#define chunksize(p) ((p)->head & ~(FLAG_BITS))
+
+#define clear_pinuse(p) ((p)->head &= ~PINUSE_BIT)
+#define set_flag4(p) ((p)->head |= FLAG4_BIT)
+#define clear_flag4(p) ((p)->head &= ~FLAG4_BIT)
+
+/* Treat space at ptr +/- offset as a chunk */
+#define chunk_plus_offset(p, s) ((mchunkptr)(((char*)(p)) + (s)))
+#define chunk_minus_offset(p, s) ((mchunkptr)(((char*)(p)) - (s)))
+
+/* Ptr to next or previous physical malloc_chunk. */
+#define next_chunk(p) ((mchunkptr)( ((char*)(p)) + ((p)->head & ~FLAG_BITS)))
+#define prev_chunk(p) ((mchunkptr)( ((char*)(p)) - ((p)->prev_foot) ))
+
+/* extract next chunk's pinuse bit */
+#define next_pinuse(p) ((next_chunk(p)->head) & PINUSE_BIT)
+
+/* Get/set size at footer */
+#define get_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot)
+#define set_foot(p, s) (((mchunkptr)((char*)(p) + (s)))->prev_foot = (s))
+
+/* Set size, pinuse bit, and foot */
+#define set_size_and_pinuse_of_free_chunk(p, s)\
+ ((p)->head = (s|PINUSE_BIT), set_foot(p, s))
+
+/* Set size, pinuse bit, foot, and clear next pinuse */
+#define set_free_with_pinuse(p, s, n)\
+ (clear_pinuse(n), set_size_and_pinuse_of_free_chunk(p, s))
+
+/* Get the internal overhead associated with chunk p */
+#define overhead_for(p)\
+ (is_mmapped(p)? MMAP_CHUNK_OVERHEAD : CHUNK_OVERHEAD)
+
+/* Return true if malloced space is not necessarily cleared */
+#if MMAP_CLEARS
+#define calloc_must_clear(p) (!is_mmapped(p))
+#else /* MMAP_CLEARS */
+#define calloc_must_clear(p) (1)
+#endif /* MMAP_CLEARS */
+
+/* ---------------------- Overlaid data structures ----------------------- */
+
+/*
+ When chunks are not in use, they are treated as nodes of either
+ lists or trees.
+
+ "Small" chunks are stored in circular doubly-linked lists, and look
+ like this:
+
+ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Size of previous chunk |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ `head:' | Size of chunk, in bytes |P|
+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Forward pointer to next chunk in list |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Back pointer to previous chunk in list |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Unused space (may be 0 bytes long) .
+ . .
+ . |
+nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ `foot:' | Size of chunk, in bytes |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ Larger chunks are kept in a form of bitwise digital trees (aka
+ tries) keyed on chunksizes. Because malloc_tree_chunks are only for
+ free chunks greater than 256 bytes, their size doesn't impose any
+ constraints on user chunk sizes. Each node looks like:
+
+ chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Size of previous chunk |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ `head:' | Size of chunk, in bytes |P|
+ mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Forward pointer to next chunk of same size |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Back pointer to previous chunk of same size |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Pointer to left child (child[0]) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Pointer to right child (child[1]) |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Pointer to parent |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | bin index of this chunk |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ | Unused space .
+ . |
+nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ `foot:' | Size of chunk, in bytes |
+ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+ Each tree holding treenodes is a tree of unique chunk sizes. Chunks
+ of the same size are arranged in a circularly-linked list, with only
+ the oldest chunk (the next to be used, in our FIFO ordering)
+ actually in the tree. (Tree members are distinguished by a non-null
+ parent pointer.) If a chunk with the same size an an existing node
+ is inserted, it is linked off the existing node using pointers that
+ work in the same way as fd/bk pointers of small chunks.
+
+ Each tree contains a power of 2 sized range of chunk sizes (the
+ smallest is 0x100 <= x < 0x180), which is is divided in half at each
+ tree level, with the chunks in the smaller half of the range (0x100
+ <= x < 0x140 for the top nose) in the left subtree and the larger
+ half (0x140 <= x < 0x180) in the right subtree. This is, of course,
+ done by inspecting individual bits.
+
+ Using these rules, each node's left subtree contains all smaller
+ sizes than its right subtree. However, the node at the root of each
+ subtree has no particular ordering relationship to either. (The
+ dividing line between the subtree sizes is based on trie relation.)
+ If we remove the last chunk of a given size from the interior of the
+ tree, we need to replace it with a leaf node. The tree ordering
+ rules permit a node to be replaced by any leaf below it.
+
+ The smallest chunk in a tree (a common operation in a best-fit
+ allocator) can be found by walking a path to the leftmost leaf in
+ the tree. Unlike a usual binary tree, where we follow left child
+ pointers until we reach a null, here we follow the right child
+ pointer any time the left one is null, until we reach a leaf with
+ both child pointers null. The smallest chunk in the tree will be
+ somewhere along that path.
+
+ The worst case number of steps to add, find, or remove a node is
+ bounded by the number of bits differentiating chunks within
+ bins. Under current bin calculations, this ranges from 6 up to 21
+ (for 32 bit sizes) or up to 53 (for 64 bit sizes). The typical case
+ is of course much better.
+*/
+
+struct malloc_tree_chunk {
+ /* The first four fields must be compatible with malloc_chunk */
+ size_t prev_foot;
+ size_t head;
+ struct malloc_tree_chunk* fd;
+ struct malloc_tree_chunk* bk;
+
+ struct malloc_tree_chunk* child[2];
+ struct malloc_tree_chunk* parent;
+ bindex_t index;
+};
+
+typedef struct malloc_tree_chunk tchunk;
+typedef struct malloc_tree_chunk* tchunkptr;
+typedef struct malloc_tree_chunk* tbinptr; /* The type of bins of trees */
+
+/* A little helper macro for trees */
+#define leftmost_child(t) ((t)->child[0] != 0? (t)->child[0] : (t)->child[1])
+
+/* ----------------------------- Segments -------------------------------- */
+
+/*
+ Each malloc space may include non-contiguous segments, held in a
+ list headed by an embedded malloc_segment record representing the
+ top-most space. Segments also include flags holding properties of
+ the space. Large chunks that are directly allocated by mmap are not
+ included in this list. They are instead independently created and
+ destroyed without otherwise keeping track of them.
+
+ Segment management mainly comes into play for spaces allocated by
+ MMAP. Any call to MMAP might or might not return memory that is
+ adjacent to an existing segment. MORECORE normally contiguously
+ extends the current space, so this space is almost always adjacent,
+ which is simpler and faster to deal with. (This is why MORECORE is
+ used preferentially to MMAP when both are available -- see
+ sys_alloc.) When allocating using MMAP, we don't use any of the
+ hinting mechanisms (inconsistently) supported in various
+ implementations of unix mmap, or distinguish reserving from
+ committing memory. Instead, we just ask for space, and exploit
+ contiguity when we get it. It is probably possible to do
+ better than this on some systems, but no general scheme seems
+ to be significantly better.
+
+ Management entails a simpler variant of the consolidation scheme
+ used for chunks to reduce fragmentation -- new adjacent memory is
+ normally prepended or appended to an existing segment. However,
+ there are limitations compared to chunk consolidation that mostly
+ reflect the fact that segment processing is relatively infrequent
+ (occurring only when getting memory from system) and that we
+ don't expect to have huge numbers of segments:
+
+ * Segments are not indexed, so traversal requires linear scans. (It
+ would be possible to index these, but is not worth the extra
+ overhead and complexity for most programs on most platforms.)
+ * New segments are only appended to old ones when holding top-most
+ memory; if they cannot be prepended to others, they are held in
+ different segments.
+
+ Except for the top-most segment of an mstate, each segment record
+ is kept at the tail of its segment. Segments are added by pushing
+ segment records onto the list headed by &mstate.seg for the
+ containing mstate.
+
+ Segment flags control allocation/merge/deallocation policies:
+ * If EXTERN_BIT set, then we did not allocate this segment,
+ and so should not try to deallocate or merge with others.
+ (This currently holds only for the initial segment passed
+ into create_mspace_with_base.)
+ * If USE_MMAP_BIT set, the segment may be merged with
+ other surrounding mmapped segments and trimmed/de-allocated
+ using munmap.
+ * If neither bit is set, then the segment was obtained using
+ MORECORE so can be merged with surrounding MORECORE'd segments
+ and deallocated/trimmed using MORECORE with negative arguments.
+*/
+
+struct malloc_segment {
+ char* base; /* base address */
+ size_t size; /* allocated size */
+ struct malloc_segment* next; /* ptr to next segment */
+ flag_t sflags; /* mmap and extern flag */
+};
+
+#define is_mmapped_segment(S) ((S)->sflags & USE_MMAP_BIT)
+#define is_extern_segment(S) ((S)->sflags & EXTERN_BIT)
+
+typedef struct malloc_segment msegment;
+typedef struct malloc_segment* msegmentptr;
+
+/* ---------------------------- malloc_state ----------------------------- */
+
+/*
+ A malloc_state holds all of the bookkeeping for a space.
+ The main fields are:
+
+ Top
+ The topmost chunk of the currently active segment. Its size is
+ cached in topsize. The actual size of topmost space is
+ topsize+TOP_FOOT_SIZE, which includes space reserved for adding
+ fenceposts and segment records if necessary when getting more
+ space from the system. The size at which to autotrim top is
+ cached from mparams in trim_check, except that it is disabled if
+ an autotrim fails.
+
+ Designated victim (dv)
+ This is the preferred chunk for servicing small requests that
+ don't have exact fits. It is normally the chunk split off most
+ recently to service another small request. Its size is cached in
+ dvsize. The link fields of this chunk are not maintained since it
+ is not kept in a bin.
+
+ SmallBins
+ An array of bin headers for free chunks. These bins hold chunks
+ with sizes less than MIN_LARGE_SIZE bytes. Each bin contains
+ chunks of all the same size, spaced 8 bytes apart. To simplify
+ use in double-linked lists, each bin header acts as a malloc_chunk
+ pointing to the real first node, if it exists (else pointing to
+ itself). This avoids special-casing for headers. But to avoid
+ waste, we allocate only the fd/bk pointers of bins, and then use
+ repositioning tricks to treat these as the fields of a chunk.
+
+ TreeBins
+ Treebins are pointers to the roots of trees holding a range of
+ sizes. There are 2 equally spaced treebins for each power of two
+ from TREE_SHIFT to TREE_SHIFT+16. The last bin holds anything
+ larger.
+
+ Bin maps
+ There is one bit map for small bins ("smallmap") and one for
+ treebins ("treemap). Each bin sets its bit when non-empty, and
+ clears the bit when empty. Bit operations are then used to avoid
+ bin-by-bin searching -- nearly all "search" is done without ever
+ looking at bins that won't be selected. The bit maps
+ conservatively use 32 bits per map word, even if on 64bit system.
+ For a good description of some of the bit-based techniques used
+ here, see Henry S. Warren Jr's book "Hacker's Delight" (and
+ supplement at http://hackersdelight.org/). Many of these are
+ intended to reduce the branchiness of paths through malloc etc, as
+ well as to reduce the number of memory locations read or written.
+
+ Segments
+ A list of segments headed by an embedded malloc_segment record
+ representing the initial space.
+
+ Address check support
+ The least_addr field is the least address ever obtained from
+ MORECORE or MMAP. Attempted frees and reallocs of any address less
+ than this are trapped (unless INSECURE is defined).
+
+ Magic tag
+ A cross-check field that should always hold same value as mparams.magic.
+
+ Max allowed footprint
+ The maximum allowed bytes to allocate from system (zero means no limit)
+
+ Flags
+ Bits recording whether to use MMAP, locks, or contiguous MORECORE
+
+ Statistics
+ Each space keeps track of current and maximum system memory
+ obtained via MORECORE or MMAP.
+
+ Trim support
+ Fields holding the amount of unused topmost memory that should trigger
+ trimming, and a counter to force periodic scanning to release unused
+ non-topmost segments.
+
+ Locking
+ If USE_LOCKS is defined, the "mutex" lock is acquired and released
+ around every public call using this mspace.
+
+ Extension support
+ A void* pointer and a size_t field that can be used to help implement
+ extensions to this malloc.
+*/
+
+/* Bin types, widths and sizes */
+#define NSMALLBINS (32U)
+#define NTREEBINS (32U)
+#define SMALLBIN_SHIFT (3U)
+#define SMALLBIN_WIDTH (SIZE_T_ONE << SMALLBIN_SHIFT)
+#define TREEBIN_SHIFT (8U)
+#define MIN_LARGE_SIZE (SIZE_T_ONE << TREEBIN_SHIFT)
+#define MAX_SMALL_SIZE (MIN_LARGE_SIZE - SIZE_T_ONE)
+#define MAX_SMALL_REQUEST (MAX_SMALL_SIZE - CHUNK_ALIGN_MASK - CHUNK_OVERHEAD)
+
+struct malloc_state {
+ binmap_t smallmap;
+ binmap_t treemap;
+ size_t dvsize;
+ size_t topsize;
+ char* least_addr;
+ mchunkptr dv;
+ mchunkptr top;
+ size_t trim_check;
+ size_t release_checks;
+ size_t magic;
+ mchunkptr smallbins[(NSMALLBINS+1)*2];
+ tbinptr treebins[NTREEBINS];
+ size_t footprint;
+ size_t max_footprint;
+ size_t footprint_limit; /* zero means no limit */
+ flag_t mflags;
+#if USE_LOCKS
+ MLOCK_T mutex; /* locate lock among fields that rarely change */
+#endif /* USE_LOCKS */
+ msegment seg;
+ void* extp; /* Unused but available for extensions */
+ size_t exts;
+};
+
+typedef struct malloc_state* mstate;
+
+/* ------------- Global malloc_state and malloc_params ------------------- */
+
+/*
+ malloc_params holds global properties, including those that can be
+ dynamically set using mallopt. There is a single instance, mparams,
+ initialized in init_mparams. Note that the non-zeroness of "magic"
+ also serves as an initialization flag.
+*/
+
+struct malloc_params {
+ size_t magic;
+ size_t page_size;
+ size_t granularity;
+ size_t mmap_threshold;
+ size_t trim_threshold;
+ flag_t default_mflags;
+};
+
+static struct malloc_params mparams;
+
+/* Ensure mparams initialized */
+#define ensure_initialization() (void)(mparams.magic != 0 || init_mparams())
+
+#if !ONLY_MSPACES
+
+/* The global malloc_state used for all non-"mspace" calls */
+static struct malloc_state _gm_;
+#define gm (&_gm_)
+#define is_global(M) ((M) == &_gm_)
+
+#endif /* !ONLY_MSPACES */
+
+#define is_initialized(M) ((M)->top != 0)
+
+/* -------------------------- system alloc setup ------------------------- */
+
+/* Operations on mflags */
+
+#define use_lock(M) ((M)->mflags & USE_LOCK_BIT)
+#define enable_lock(M) ((M)->mflags |= USE_LOCK_BIT)
+#if USE_LOCKS
+#define disable_lock(M) ((M)->mflags &= ~USE_LOCK_BIT)
+#else
+#define disable_lock(M)
+#endif
+
+#define use_mmap(M) ((M)->mflags & USE_MMAP_BIT)
+#define enable_mmap(M) ((M)->mflags |= USE_MMAP_BIT)
+#if HAVE_MMAP
+#define disable_mmap(M) ((M)->mflags &= ~USE_MMAP_BIT)
+#else
+#define disable_mmap(M)
+#endif
+
+#define use_noncontiguous(M) ((M)->mflags & USE_NONCONTIGUOUS_BIT)
+#define disable_contiguous(M) ((M)->mflags |= USE_NONCONTIGUOUS_BIT)
+
+#define set_lock(M,L)\
+ ((M)->mflags = (L)?\
+ ((M)->mflags | USE_LOCK_BIT) :\
+ ((M)->mflags & ~USE_LOCK_BIT))
+
+/* page-align a size */
+#define page_align(S)\
+ (((S) + (mparams.page_size - SIZE_T_ONE)) & ~(mparams.page_size - SIZE_T_ONE))
+
+/* granularity-align a size */
+#define granularity_align(S)\
+ (((S) + (mparams.granularity - SIZE_T_ONE))\
+ & ~(mparams.granularity - SIZE_T_ONE))
+
+
+/* For mmap, use granularity alignment on windows, else page-align */
+#ifdef WIN32
+#define mmap_align(S) granularity_align(S)
+#else
+#define mmap_align(S) page_align(S)
+#endif
+
+/* For sys_alloc, enough padding to ensure can malloc request on success */
+#define SYS_ALLOC_PADDING (TOP_FOOT_SIZE + MALLOC_ALIGNMENT)
+
+#define is_page_aligned(S)\
+ (((size_t)(S) & (mparams.page_size - SIZE_T_ONE)) == 0)
+#define is_granularity_aligned(S)\
+ (((size_t)(S) & (mparams.granularity - SIZE_T_ONE)) == 0)
+
+/* True if segment S holds address A */
+#define segment_holds(S, A)\
+ ((char*)(A) >= S->base && (char*)(A) < S->base + S->size)
+
+/* Return segment holding given address */
+static msegmentptr segment_holding(mstate m, char* addr) {
+ msegmentptr sp = &m->seg;
+ for (;;) {
+ if (addr >= sp->base && addr < sp->base + sp->size)
+ return sp;
+ if ((sp = sp->next) == 0)
+ return 0;
+ }
+}
+
+/* Return true if segment contains a segment link */
+static int has_segment_link(mstate m, msegmentptr ss) {
+ msegmentptr sp = &m->seg;
+ for (;;) {
+ if ((char*)sp >= ss->base && (char*)sp < ss->base + ss->size)
+ return 1;
+ if ((sp = sp->next) == 0)
+ return 0;
+ }
+}
+
+#ifndef MORECORE_CANNOT_TRIM
+#define should_trim(M,s) ((s) > (M)->trim_check)
+#else /* MORECORE_CANNOT_TRIM */
+#define should_trim(M,s) (0)
+#endif /* MORECORE_CANNOT_TRIM */
+
+/*
+ TOP_FOOT_SIZE is padding at the end of a segment, including space
+ that may be needed to place segment records and fenceposts when new
+ noncontiguous segments are added.
+*/
+#define TOP_FOOT_SIZE\
+ (align_offset(chunk2mem(0))+pad_request(sizeof(struct malloc_segment))+MIN_CHUNK_SIZE)
+
+
+/* ------------------------------- Hooks -------------------------------- */
+
+/*
+ PREACTION should be defined to return 0 on success, and nonzero on
+ failure. If you are not using locking, you can redefine these to do
+ anything you like.
+*/
+
+#if USE_LOCKS
+#define PREACTION(M) ((use_lock(M))? ACQUIRE_LOCK(&(M)->mutex) : 0)
+#define POSTACTION(M) { if (use_lock(M)) RELEASE_LOCK(&(M)->mutex); }
+#else /* USE_LOCKS */
+
+#ifndef PREACTION
+#define PREACTION(M) (0)
+#endif /* PREACTION */
+
+#ifndef POSTACTION
+#define POSTACTION(M)
+#endif /* POSTACTION */
+
+#endif /* USE_LOCKS */
+
+/*
+ CORRUPTION_ERROR_ACTION is triggered upon detected bad addresses.
+ USAGE_ERROR_ACTION is triggered on detected bad frees and
+ reallocs. The argument p is an address that might have triggered the
+ fault. It is ignored by the two predefined actions, but might be
+ useful in custom actions that try to help diagnose errors.
+*/
+
+#if PROCEED_ON_ERROR
+
+/* A count of the number of corruption errors causing resets */
+int malloc_corruption_error_count;
+
+/* default corruption action */
+static void reset_on_error(mstate m);
+
+#define CORRUPTION_ERROR_ACTION(m) reset_on_error(m)
+#define USAGE_ERROR_ACTION(m, p)
+
+#else /* PROCEED_ON_ERROR */
+
+#ifndef CORRUPTION_ERROR_ACTION
+#define CORRUPTION_ERROR_ACTION(m) ABORT
+#endif /* CORRUPTION_ERROR_ACTION */
+
+#ifndef USAGE_ERROR_ACTION
+#define USAGE_ERROR_ACTION(m,p) ABORT
+#endif /* USAGE_ERROR_ACTION */
+
+#endif /* PROCEED_ON_ERROR */
+
+
+/* -------------------------- Debugging setup ---------------------------- */
+
+#if ! DEBUG
+
+#define check_free_chunk(M,P)
+#define check_inuse_chunk(M,P)
+#define check_malloced_chunk(M,P,N)
+#define check_mmapped_chunk(M,P)
+#define check_malloc_state(M)
+#define check_top_chunk(M,P)
+
+#else /* DEBUG */
+#define check_free_chunk(M,P) do_check_free_chunk(M,P)
+#define check_inuse_chunk(M,P) do_check_inuse_chunk(M,P)
+#define check_top_chunk(M,P) do_check_top_chunk(M,P)
+#define check_malloced_chunk(M,P,N) do_check_malloced_chunk(M,P,N)
+#define check_mmapped_chunk(M,P) do_check_mmapped_chunk(M,P)
+#define check_malloc_state(M) do_check_malloc_state(M)
+
+static void do_check_any_chunk(mstate m, mchunkptr p);
+static void do_check_top_chunk(mstate m, mchunkptr p);
+static void do_check_mmapped_chunk(mstate m, mchunkptr p);
+static void do_check_inuse_chunk(mstate m, mchunkptr p);
+static void do_check_free_chunk(mstate m, mchunkptr p);
+static void do_check_malloced_chunk(mstate m, void* mem, size_t s);
+static void do_check_tree(mstate m, tchunkptr t);
+static void do_check_treebin(mstate m, bindex_t i);
+static void do_check_smallbin(mstate m, bindex_t i);
+static void do_check_malloc_state(mstate m);
+static int bin_find(mstate m, mchunkptr x);
+static size_t traverse_and_check(mstate m);
+#endif /* DEBUG */
+
+/* ---------------------------- Indexing Bins ---------------------------- */
+
+#define is_small(s) (((s) >> SMALLBIN_SHIFT) < NSMALLBINS)
+#define small_index(s) (bindex_t)((s) >> SMALLBIN_SHIFT)
+#define small_index2size(i) ((i) << SMALLBIN_SHIFT)
+#define MIN_SMALL_INDEX (small_index(MIN_CHUNK_SIZE))
+
+/* addressing by index. See above about smallbin repositioning */
+#define smallbin_at(M, i) ((sbinptr)((char*)&((M)->smallbins[(i)<<1])))
+#define treebin_at(M,i) (&((M)->treebins[i]))
+
+/* assign tree index for size S to variable I. Use x86 asm if possible */
+#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+#define compute_tree_index(S, I)\
+{\
+ unsigned int X = S >> TREEBIN_SHIFT;\
+ if (X == 0)\
+ I = 0;\
+ else if (X > 0xFFFF)\
+ I = NTREEBINS-1;\
+ else {\
+ unsigned int K = (unsigned) sizeof(X)*__CHAR_BIT__ - 1 - (unsigned) __builtin_clz(X); \
+ I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\
+ }\
+}
+
+#elif defined (__INTEL_COMPILER)
+#define compute_tree_index(S, I)\
+{\
+ size_t X = S >> TREEBIN_SHIFT;\
+ if (X == 0)\
+ I = 0;\
+ else if (X > 0xFFFF)\
+ I = NTREEBINS-1;\
+ else {\
+ unsigned int K = _bit_scan_reverse (X); \
+ I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\
+ }\
+}
+
+#elif defined(_MSC_VER) && _MSC_VER>=1300
+#define compute_tree_index(S, I)\
+{\
+ size_t X = S >> TREEBIN_SHIFT;\
+ if (X == 0)\
+ I = 0;\
+ else if (X > 0xFFFF)\
+ I = NTREEBINS-1;\
+ else {\
+ unsigned int K;\
+ _BitScanReverse((DWORD *) &K, (DWORD) X);\
+ I = (bindex_t)((K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1)));\
+ }\
+}
+
+#else /* GNUC */
+#define compute_tree_index(S, I)\
+{\
+ size_t X = S >> TREEBIN_SHIFT;\
+ if (X == 0)\
+ I = 0;\
+ else if (X > 0xFFFF)\
+ I = NTREEBINS-1;\
+ else {\
+ unsigned int Y = (unsigned int)X;\
+ unsigned int N = ((Y - 0x100) >> 16) & 8;\
+ unsigned int K = (((Y <<= N) - 0x1000) >> 16) & 4;\
+ N += K;\
+ N += K = (((Y <<= K) - 0x4000) >> 16) & 2;\
+ K = 14 - N + ((Y <<= K) >> 15);\
+ I = (K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1));\
+ }\
+}
+#endif /* GNUC */
+
+/* Bit representing maximum resolved size in a treebin at i */
+#define bit_for_tree_index(i) \
+ (i == NTREEBINS-1)? (SIZE_T_BITSIZE-1) : (((i) >> 1) + TREEBIN_SHIFT - 2)
+
+/* Shift placing maximum resolved bit in a treebin at i as sign bit */
+#define leftshift_for_tree_index(i) \
+ ((i == NTREEBINS-1)? 0 : \
+ ((SIZE_T_BITSIZE-SIZE_T_ONE) - (((i) >> 1) + TREEBIN_SHIFT - 2)))
+
+/* The size of the smallest chunk held in bin with index i */
+#define minsize_for_tree_index(i) \
+ ((SIZE_T_ONE << (((i) >> 1) + TREEBIN_SHIFT)) | \
+ (((size_t)((i) & SIZE_T_ONE)) << (((i) >> 1) + TREEBIN_SHIFT - 1)))
+
+
+/* ------------------------ Operations on bin maps ----------------------- */
+
+/* bit corresponding to given index */
+#define idx2bit(i) ((binmap_t)(1) << (i))
+
+/* Mark/Clear bits with given index */
+#define mark_smallmap(M,i) ((M)->smallmap |= idx2bit(i))
+#define clear_smallmap(M,i) ((M)->smallmap &= ~idx2bit(i))
+#define smallmap_is_marked(M,i) ((M)->smallmap & idx2bit(i))
+
+#define mark_treemap(M,i) ((M)->treemap |= idx2bit(i))
+#define clear_treemap(M,i) ((M)->treemap &= ~idx2bit(i))
+#define treemap_is_marked(M,i) ((M)->treemap & idx2bit(i))
+
+/* isolate the least set bit of a bitmap */
+#define least_bit(x) ((x) & -(x))
+
+/* mask with all bits to left of least bit of x on */
+#define left_bits(x) ((x<<1) | -(x<<1))
+
+/* mask with all bits to left of or equal to least bit of x on */
+#define same_or_left_bits(x) ((x) | -(x))
+
+/* index corresponding to given bit. Use x86 asm if possible */
+
+#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
+#define compute_bit2idx(X, I)\
+{\
+ unsigned int J;\
+ J = __builtin_ctz(X); \
+ I = (bindex_t)J;\
+}
+
+#elif defined (__INTEL_COMPILER)
+#define compute_bit2idx(X, I)\
+{\
+ unsigned int J;\
+ J = _bit_scan_forward (X); \
+ I = (bindex_t)J;\
+}
+
+#elif defined(_MSC_VER) && _MSC_VER>=1300
+#define compute_bit2idx(X, I)\
+{\
+ unsigned int J;\
+ _BitScanForward((DWORD *) &J, X);\
+ I = (bindex_t)J;\
+}
+
+#elif USE_BUILTIN_FFS
+#define compute_bit2idx(X, I) I = ffs(X)-1
+
+#else
+#define compute_bit2idx(X, I)\
+{\
+ unsigned int Y = X - 1;\
+ unsigned int K = Y >> (16-4) & 16;\
+ unsigned int N = K; Y >>= K;\
+ N += K = Y >> (8-3) & 8; Y >>= K;\
+ N += K = Y >> (4-2) & 4; Y >>= K;\
+ N += K = Y >> (2-1) & 2; Y >>= K;\
+ N += K = Y >> (1-0) & 1; Y >>= K;\
+ I = (bindex_t)(N + Y);\
+}
+#endif /* GNUC */
+
+
+/* ----------------------- Runtime Check Support ------------------------- */
+
+/*
+ For security, the main invariant is that malloc/free/etc never
+ writes to a static address other than malloc_state, unless static
+ malloc_state itself has been corrupted, which cannot occur via
+ malloc (because of these checks). In essence this means that we
+ believe all pointers, sizes, maps etc held in malloc_state, but
+ check all of those linked or offsetted from other embedded data
+ structures. These checks are interspersed with main code in a way
+ that tends to minimize their run-time cost.
+
+ When FOOTERS is defined, in addition to range checking, we also
+ verify footer fields of inuse chunks, which can be used guarantee
+ that the mstate controlling malloc/free is intact. This is a
+ streamlined version of the approach described by William Robertson
+ et al in "Run-time Detection of Heap-based Overflows" LISA'03
+ http://www.usenix.org/events/lisa03/tech/robertson.html The footer
+ of an inuse chunk holds the xor of its mstate and a random seed,
+ that is checked upon calls to free() and realloc(). This is
+ (probabalistically) unguessable from outside the program, but can be
+ computed by any code successfully malloc'ing any chunk, so does not
+ itself provide protection against code that has already broken
+ security through some other means. Unlike Robertson et al, we
+ always dynamically check addresses of all offset chunks (previous,
+ next, etc). This turns out to be cheaper than relying on hashes.
+*/
+
+#if !INSECURE
+/* Check if address a is at least as high as any from MORECORE or MMAP */
+#define ok_address(M, a) ((char*)(a) >= (M)->least_addr)
+/* Check if address of next chunk n is higher than base chunk p */
+#define ok_next(p, n) ((char*)(p) < (char*)(n))
+/* Check if p has inuse status */
+#define ok_inuse(p) is_inuse(p)
+/* Check if p has its pinuse bit on */
+#define ok_pinuse(p) pinuse(p)
+
+#else /* !INSECURE */
+#define ok_address(M, a) (1)
+#define ok_next(b, n) (1)
+#define ok_inuse(p) (1)
+#define ok_pinuse(p) (1)
+#endif /* !INSECURE */
+
+#if (FOOTERS && !INSECURE)
+/* Check if (alleged) mstate m has expected magic field */
+#define ok_magic(M) ((M)->magic == mparams.magic)
+#else /* (FOOTERS && !INSECURE) */
+#define ok_magic(M) (1)
+#endif /* (FOOTERS && !INSECURE) */
+
+/* In gcc, use __builtin_expect to minimize impact of checks */
+#if !INSECURE
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define RTCHECK(e) __builtin_expect(e, 1)
+#else /* GNUC */
+#define RTCHECK(e) (e)
+#endif /* GNUC */
+#else /* !INSECURE */
+#define RTCHECK(e) (1)
+#endif /* !INSECURE */
+
+/* macros to set up inuse chunks with or without footers */
+
+#if !FOOTERS
+
+#define mark_inuse_foot(M,p,s)
+
+/* Macros for setting head/foot of non-mmapped chunks */
+
+/* Set cinuse bit and pinuse bit of next chunk */
+#define set_inuse(M,p,s)\
+ ((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\
+ ((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT)
+
+/* Set cinuse and pinuse of this chunk and pinuse of next chunk */
+#define set_inuse_and_pinuse(M,p,s)\
+ ((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\
+ ((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT)
+
+/* Set size, cinuse and pinuse bit of this chunk */
+#define set_size_and_pinuse_of_inuse_chunk(M, p, s)\
+ ((p)->head = (s|PINUSE_BIT|CINUSE_BIT))
+
+#else /* FOOTERS */
+
+/* Set foot of inuse chunk to be xor of mstate and seed */
+#define mark_inuse_foot(M,p,s)\
+ (((mchunkptr)((char*)(p) + (s)))->prev_foot = ((size_t)(M) ^ mparams.magic))
+
+#define get_mstate_for(p)\
+ ((mstate)(((mchunkptr)((char*)(p) +\
+ (chunksize(p))))->prev_foot ^ mparams.magic))
+
+#define set_inuse(M,p,s)\
+ ((p)->head = (((p)->head & PINUSE_BIT)|s|CINUSE_BIT),\
+ (((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT), \
+ mark_inuse_foot(M,p,s))
+
+#define set_inuse_and_pinuse(M,p,s)\
+ ((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\
+ (((mchunkptr)(((char*)(p)) + (s)))->head |= PINUSE_BIT),\
+ mark_inuse_foot(M,p,s))
+
+#define set_size_and_pinuse_of_inuse_chunk(M, p, s)\
+ ((p)->head = (s|PINUSE_BIT|CINUSE_BIT),\
+ mark_inuse_foot(M, p, s))
+
+#endif /* !FOOTERS */
+
+/* ---------------------------- setting mparams -------------------------- */
+
+/* Initialize mparams */
+static int init_mparams(void) {
+#ifdef NEED_GLOBAL_LOCK_INIT
+ if (malloc_global_mutex_status <= 0)
+ init_malloc_global_mutex();
+#endif
+
+ ACQUIRE_MALLOC_GLOBAL_LOCK();
+ if (mparams.magic == 0) {
+ size_t magic;
+ size_t psize;
+ size_t gsize;
+
+#ifndef WIN32
+ psize = malloc_getpagesize;
+ gsize = ((DEFAULT_GRANULARITY != 0)? DEFAULT_GRANULARITY : psize);
+#else /* WIN32 */
+ {
+ SYSTEM_INFO system_info;
+ GetSystemInfo(&system_info);
+ psize = system_info.dwPageSize;
+ gsize = ((DEFAULT_GRANULARITY != 0)?
+ DEFAULT_GRANULARITY : system_info.dwAllocationGranularity);
+ }
+#endif /* WIN32 */
+
+ /* Sanity-check configuration:
+ size_t must be unsigned and as wide as pointer type.
+ ints must be at least 4 bytes.
+ alignment must be at least 8.
+ Alignment, min chunk size, and page size must all be powers of 2.
+ */
+ if ((sizeof(size_t) != sizeof(char*)) ||
+ (MAX_SIZE_T < MIN_CHUNK_SIZE) ||
+ (sizeof(int) < 4) ||
+ (MALLOC_ALIGNMENT < (size_t)8U) ||
+ ((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-SIZE_T_ONE)) != 0) ||
+ ((MCHUNK_SIZE & (MCHUNK_SIZE-SIZE_T_ONE)) != 0) ||
+ ((gsize & (gsize-SIZE_T_ONE)) != 0) ||
+ ((psize & (psize-SIZE_T_ONE)) != 0))
+ ABORT;
+
+ mparams.granularity = gsize;
+ mparams.page_size = psize;
+ mparams.mmap_threshold = DEFAULT_MMAP_THRESHOLD;
+ mparams.trim_threshold = DEFAULT_TRIM_THRESHOLD;
+#if MORECORE_CONTIGUOUS
+ mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT;
+#else /* MORECORE_CONTIGUOUS */
+ mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT|USE_NONCONTIGUOUS_BIT;
+#endif /* MORECORE_CONTIGUOUS */
+
+#if !ONLY_MSPACES
+ /* Set up lock for main malloc area */
+ gm->mflags = mparams.default_mflags;
+ (void)INITIAL_LOCK(&gm->mutex);
+#endif
+
+ {
+#if USE_DEV_RANDOM
+ int fd;
+ unsigned char buf[sizeof(size_t)];
+ /* Try to use /dev/urandom, else fall back on using time */
+ if ((fd = open("/dev/urandom", O_RDONLY)) >= 0 &&
+ read(fd, buf, sizeof(buf)) == sizeof(buf)) {
+ magic = *((size_t *) buf);
+ close(fd);
+ }
+ else
+#endif /* USE_DEV_RANDOM */
+#ifdef WIN32
+ magic = (size_t)(GetTickCount() ^ (size_t)0x55555555U);
+#elif defined(LACKS_TIME_H)
+ magic = (size_t)&magic ^ (size_t)0x55555555U;
+#else
+ magic = (size_t)(time(0) ^ (size_t)0x55555555U);
+#endif
+ magic |= (size_t)8U; /* ensure nonzero */
+ magic &= ~(size_t)7U; /* improve chances of fault for bad values */
+ /* Until memory modes commonly available, use volatile-write */
+ (*(volatile size_t *)(&(mparams.magic))) = magic;
+ }
+ }
+
+ RELEASE_MALLOC_GLOBAL_LOCK();
+ return 1;
+}
+
+/* support for mallopt */
+static int change_mparam(int param_number, int value) {
+ size_t val;
+ ensure_initialization();
+ val = (value == -1)? MAX_SIZE_T : (size_t)value;
+ switch(param_number) {
+ case M_TRIM_THRESHOLD:
+ mparams.trim_threshold = val;
+ return 1;
+ case M_GRANULARITY:
+ if (val >= mparams.page_size && ((val & (val-1)) == 0)) {
+ mparams.granularity = val;
+ return 1;
+ }
+ else
+ return 0;
+ case M_MMAP_THRESHOLD:
+ mparams.mmap_threshold = val;
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+#if DEBUG
+/* ------------------------- Debugging Support --------------------------- */
+
+/* Check properties of any chunk, whether free, inuse, mmapped etc */
+static void do_check_any_chunk(mstate m, mchunkptr p) {
+ assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
+ assert(ok_address(m, p));
+}
+
+/* Check properties of top chunk */
+static void do_check_top_chunk(mstate m, mchunkptr p) {
+ msegmentptr sp = segment_holding(m, (char*)p);
+ size_t sz = p->head & ~INUSE_BITS; /* third-lowest bit can be set! */
+ assert(sp != 0);
+ assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
+ assert(ok_address(m, p));
+ assert(sz == m->topsize);
+ assert(sz > 0);
+ assert(sz == ((sp->base + sp->size) - (char*)p) - TOP_FOOT_SIZE);
+ assert(pinuse(p));
+ assert(!pinuse(chunk_plus_offset(p, sz)));
+}
+
+/* Check properties of (inuse) mmapped chunks */
+static void do_check_mmapped_chunk(mstate m, mchunkptr p) {
+ size_t sz = chunksize(p);
+ size_t len = (sz + (p->prev_foot) + MMAP_FOOT_PAD);
+ assert(is_mmapped(p));
+ assert(use_mmap(m));
+ assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
+ assert(ok_address(m, p));
+ assert(!is_small(sz));
+ assert((len & (mparams.page_size-SIZE_T_ONE)) == 0);
+ assert(chunk_plus_offset(p, sz)->head == FENCEPOST_HEAD);
+ assert(chunk_plus_offset(p, sz+SIZE_T_SIZE)->head == 0);
+}
+
+/* Check properties of inuse chunks */
+static void do_check_inuse_chunk(mstate m, mchunkptr p) {
+ do_check_any_chunk(m, p);
+ assert(is_inuse(p));
+ assert(next_pinuse(p));
+ /* If not pinuse and not mmapped, previous chunk has OK offset */
+ assert(is_mmapped(p) || pinuse(p) || next_chunk(prev_chunk(p)) == p);
+ if (is_mmapped(p))
+ do_check_mmapped_chunk(m, p);
+}
+
+/* Check properties of free chunks */
+static void do_check_free_chunk(mstate m, mchunkptr p) {
+ size_t sz = chunksize(p);
+ mchunkptr next = chunk_plus_offset(p, sz);
+ do_check_any_chunk(m, p);
+ assert(!is_inuse(p));
+ assert(!next_pinuse(p));
+ assert (!is_mmapped(p));
+ if (p != m->dv && p != m->top) {
+ if (sz >= MIN_CHUNK_SIZE) {
+ assert((sz & CHUNK_ALIGN_MASK) == 0);
+ assert(is_aligned(chunk2mem(p)));
+ assert(next->prev_foot == sz);
+ assert(pinuse(p));
+ assert (next == m->top || is_inuse(next));
+ assert(p->fd->bk == p);
+ assert(p->bk->fd == p);
+ }
+ else /* markers are always of size SIZE_T_SIZE */
+ assert(sz == SIZE_T_SIZE);
+ }
+}
+
+/* Check properties of malloced chunks at the point they are malloced */
+static void do_check_malloced_chunk(mstate m, void* mem, size_t s) {
+ if (mem != 0) {
+ mchunkptr p = mem2chunk(mem);
+ size_t sz = p->head & ~INUSE_BITS;
+ do_check_inuse_chunk(m, p);
+ assert((sz & CHUNK_ALIGN_MASK) == 0);
+ assert(sz >= MIN_CHUNK_SIZE);
+ assert(sz >= s);
+ /* unless mmapped, size is less than MIN_CHUNK_SIZE more than request */
+ assert(is_mmapped(p) || sz < (s + MIN_CHUNK_SIZE));
+ }
+}
+
+/* Check a tree and its subtrees. */
+static void do_check_tree(mstate m, tchunkptr t) {
+ tchunkptr head = 0;
+ tchunkptr u = t;
+ bindex_t tindex = t->index;
+ size_t tsize = chunksize(t);
+ bindex_t idx;
+ compute_tree_index(tsize, idx);
+ assert(tindex == idx);
+ assert(tsize >= MIN_LARGE_SIZE);
+ assert(tsize >= minsize_for_tree_index(idx));
+ assert((idx == NTREEBINS-1) || (tsize < minsize_for_tree_index((idx+1))));
+
+ do { /* traverse through chain of same-sized nodes */
+ do_check_any_chunk(m, ((mchunkptr)u));
+ assert(u->index == tindex);
+ assert(chunksize(u) == tsize);
+ assert(!is_inuse(u));
+ assert(!next_pinuse(u));
+ assert(u->fd->bk == u);
+ assert(u->bk->fd == u);
+ if (u->parent == 0) {
+ assert(u->child[0] == 0);
+ assert(u->child[1] == 0);
+ }
+ else {
+ assert(head == 0); /* only one node on chain has parent */
+ head = u;
+ assert(u->parent != u);
+ assert (u->parent->child[0] == u ||
+ u->parent->child[1] == u ||
+ *((tbinptr*)(u->parent)) == u);
+ if (u->child[0] != 0) {
+ assert(u->child[0]->parent == u);
+ assert(u->child[0] != u);
+ do_check_tree(m, u->child[0]);
+ }
+ if (u->child[1] != 0) {
+ assert(u->child[1]->parent == u);
+ assert(u->child[1] != u);
+ do_check_tree(m, u->child[1]);
+ }
+ if (u->child[0] != 0 && u->child[1] != 0) {
+ assert(chunksize(u->child[0]) < chunksize(u->child[1]));
+ }
+ }
+ u = u->fd;
+ } while (u != t);
+ assert(head != 0);
+}
+
+/* Check all the chunks in a treebin. */
+static void do_check_treebin(mstate m, bindex_t i) {
+ tbinptr* tb = treebin_at(m, i);
+ tchunkptr t = *tb;
+ int empty = (m->treemap & (1U << i)) == 0;
+ if (t == 0)
+ assert(empty);
+ if (!empty)
+ do_check_tree(m, t);
+}
+
+/* Check all the chunks in a smallbin. */
+static void do_check_smallbin(mstate m, bindex_t i) {
+ sbinptr b = smallbin_at(m, i);
+ mchunkptr p = b->bk;
+ unsigned int empty = (m->smallmap & (1U << i)) == 0;
+ if (p == b)
+ assert(empty);
+ if (!empty) {
+ for (; p != b; p = p->bk) {
+ size_t size = chunksize(p);
+ mchunkptr q;
+ /* each chunk claims to be free */
+ do_check_free_chunk(m, p);
+ /* chunk belongs in bin */
+ assert(small_index(size) == i);
+ assert(p->bk == b || chunksize(p->bk) == chunksize(p));
+ /* chunk is followed by an inuse chunk */
+ q = next_chunk(p);
+ if (q->head != FENCEPOST_HEAD)
+ do_check_inuse_chunk(m, q);
+ }
+ }
+}
+
+/* Find x in a bin. Used in other check functions. */
+static int bin_find(mstate m, mchunkptr x) {
+ size_t size = chunksize(x);
+ if (is_small(size)) {
+ bindex_t sidx = small_index(size);
+ sbinptr b = smallbin_at(m, sidx);
+ if (smallmap_is_marked(m, sidx)) {
+ mchunkptr p = b;
+ do {
+ if (p == x)
+ return 1;
+ } while ((p = p->fd) != b);
+ }
+ }
+ else {
+ bindex_t tidx;
+ compute_tree_index(size, tidx);
+ if (treemap_is_marked(m, tidx)) {
+ tchunkptr t = *treebin_at(m, tidx);
+ size_t sizebits = size << leftshift_for_tree_index(tidx);
+ while (t != 0 && chunksize(t) != size) {
+ t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1];
+ sizebits <<= 1;
+ }
+ if (t != 0) {
+ tchunkptr u = t;
+ do {
+ if (u == (tchunkptr)x)
+ return 1;
+ } while ((u = u->fd) != t);
+ }
+ }
+ }
+ return 0;
+}
+
+/* Traverse each chunk and check it; return total */
+static size_t traverse_and_check(mstate m) {
+ size_t sum = 0;
+ if (is_initialized(m)) {
+ msegmentptr s = &m->seg;
+ sum += m->topsize + TOP_FOOT_SIZE;
+ while (s != 0) {
+ mchunkptr q = align_as_chunk(s->base);
+ mchunkptr lastq = 0;
+ assert(pinuse(q));
+ while (segment_holds(s, q) &&
+ q != m->top && q->head != FENCEPOST_HEAD) {
+ sum += chunksize(q);
+ if (is_inuse(q)) {
+ assert(!bin_find(m, q));
+ do_check_inuse_chunk(m, q);
+ }
+ else {
+ assert(q == m->dv || bin_find(m, q));
+ assert(lastq == 0 || is_inuse(lastq)); /* Not 2 consecutive free */
+ do_check_free_chunk(m, q);
+ }
+ lastq = q;
+ q = next_chunk(q);
+ }
+ s = s->next;
+ }
+ }
+ return sum;
+}
+
+
+/* Check all properties of malloc_state. */
+static void do_check_malloc_state(mstate m) {
+ bindex_t i;
+ size_t total;
+ /* check bins */
+ for (i = 0; i < NSMALLBINS; ++i)
+ do_check_smallbin(m, i);
+ for (i = 0; i < NTREEBINS; ++i)
+ do_check_treebin(m, i);
+
+ if (m->dvsize != 0) { /* check dv chunk */
+ do_check_any_chunk(m, m->dv);
+ assert(m->dvsize == chunksize(m->dv));
+ assert(m->dvsize >= MIN_CHUNK_SIZE);
+ assert(bin_find(m, m->dv) == 0);
+ }
+
+ if (m->top != 0) { /* check top chunk */
+ do_check_top_chunk(m, m->top);
+ /*assert(m->topsize == chunksize(m->top)); redundant */
+ assert(m->topsize > 0);
+ assert(bin_find(m, m->top) == 0);
+ }
+
+ total = traverse_and_check(m);
+ assert(total <= m->footprint);
+ assert(m->footprint <= m->max_footprint);
+}
+#endif /* DEBUG */
+
+/* ----------------------------- statistics ------------------------------ */
+
+#if !NO_MALLINFO
+static struct mallinfo internal_mallinfo(mstate m) {
+ struct mallinfo nm = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+ ensure_initialization();
+ if (!PREACTION(m)) {
+ check_malloc_state(m);
+ if (is_initialized(m)) {
+ size_t nfree = SIZE_T_ONE; /* top always free */
+ size_t mfree = m->topsize + TOP_FOOT_SIZE;
+ size_t sum = mfree;
+ msegmentptr s = &m->seg;
+ while (s != 0) {
+ mchunkptr q = align_as_chunk(s->base);
+ while (segment_holds(s, q) &&
+ q != m->top && q->head != FENCEPOST_HEAD) {
+ size_t sz = chunksize(q);
+ sum += sz;
+ if (!is_inuse(q)) {
+ mfree += sz;
+ ++nfree;
+ }
+ q = next_chunk(q);
+ }
+ s = s->next;
+ }
+
+ nm.arena = sum;
+ nm.ordblks = nfree;
+ nm.hblkhd = m->footprint - sum;
+ nm.usmblks = m->max_footprint;
+ nm.uordblks = m->footprint - mfree;
+ nm.fordblks = mfree;
+ nm.keepcost = m->topsize;
+ }
+
+ POSTACTION(m);
+ }
+ return nm;
+}
+#endif /* !NO_MALLINFO */
+
+#if !NO_MALLOC_STATS
+static void internal_malloc_stats(mstate m) {
+ ensure_initialization();
+ if (!PREACTION(m)) {
+ size_t maxfp = 0;
+ size_t fp = 0;
+ size_t used = 0;
+ check_malloc_state(m);
+ if (is_initialized(m)) {
+ msegmentptr s = &m->seg;
+ maxfp = m->max_footprint;
+ fp = m->footprint;
+ used = fp - (m->topsize + TOP_FOOT_SIZE);
+
+ while (s != 0) {
+ mchunkptr q = align_as_chunk(s->base);
+ while (segment_holds(s, q) &&
+ q != m->top && q->head != FENCEPOST_HEAD) {
+ if (!is_inuse(q))
+ used -= chunksize(q);
+ q = next_chunk(q);
+ }
+ s = s->next;
+ }
+ }
+ POSTACTION(m); /* drop lock */
+ fprintf(stderr, "max system bytes = %10lu\n", (unsigned long)(maxfp));
+ fprintf(stderr, "system bytes = %10lu\n", (unsigned long)(fp));
+ fprintf(stderr, "in use bytes = %10lu\n", (unsigned long)(used));
+ }
+}
+#endif /* NO_MALLOC_STATS */
+
+/* ----------------------- Operations on smallbins ----------------------- */
+
+/*
+ Various forms of linking and unlinking are defined as macros. Even
+ the ones for trees, which are very long but have very short typical
+ paths. This is ugly but reduces reliance on inlining support of
+ compilers.
+*/
+
+/* Link a free chunk into a smallbin */
+#define insert_small_chunk(M, P, S) {\
+ bindex_t I = small_index(S);\
+ mchunkptr B = smallbin_at(M, I);\
+ mchunkptr F = B;\
+ assert(S >= MIN_CHUNK_SIZE);\
+ if (!smallmap_is_marked(M, I))\
+ mark_smallmap(M, I);\
+ else if (RTCHECK(ok_address(M, B->fd)))\
+ F = B->fd;\
+ else {\
+ CORRUPTION_ERROR_ACTION(M);\
+ }\
+ B->fd = P;\
+ F->bk = P;\
+ P->fd = F;\
+ P->bk = B;\
+}
+
+/* Unlink a chunk from a smallbin */
+#define unlink_small_chunk(M, P, S) {\
+ mchunkptr F = P->fd;\
+ mchunkptr B = P->bk;\
+ bindex_t I = small_index(S);\
+ assert(P != B);\
+ assert(P != F);\
+ assert(chunksize(P) == small_index2size(I));\
+ if (RTCHECK(F == smallbin_at(M,I) || (ok_address(M, F) && F->bk == P))) { \
+ if (B == F) {\
+ clear_smallmap(M, I);\
+ }\
+ else if (RTCHECK(B == smallbin_at(M,I) ||\
+ (ok_address(M, B) && B->fd == P))) {\
+ F->bk = B;\
+ B->fd = F;\
+ }\
+ else {\
+ CORRUPTION_ERROR_ACTION(M);\
+ }\
+ }\
+ else {\
+ CORRUPTION_ERROR_ACTION(M);\
+ }\
+}
+
+/* Unlink the first chunk from a smallbin */
+#define unlink_first_small_chunk(M, B, P, I) {\
+ mchunkptr F = P->fd;\
+ assert(P != B);\
+ assert(P != F);\
+ assert(chunksize(P) == small_index2size(I));\
+ if (B == F) {\
+ clear_smallmap(M, I);\
+ }\
+ else if (RTCHECK(ok_address(M, F) && F->bk == P)) {\
+ F->bk = B;\
+ B->fd = F;\
+ }\
+ else {\
+ CORRUPTION_ERROR_ACTION(M);\
+ }\
+}
+
+/* Replace dv node, binning the old one */
+/* Used only when dvsize known to be small */
+#define replace_dv(M, P, S) {\
+ size_t DVS = M->dvsize;\
+ assert(is_small(DVS));\
+ if (DVS != 0) {\
+ mchunkptr DV = M->dv;\
+ insert_small_chunk(M, DV, DVS);\
+ }\
+ M->dvsize = S;\
+ M->dv = P;\
+}
+
+/* ------------------------- Operations on trees ------------------------- */
+
+/* Insert chunk into tree */
+#define insert_large_chunk(M, X, S) {\
+ tbinptr* H;\
+ bindex_t I;\
+ compute_tree_index(S, I);\
+ H = treebin_at(M, I);\
+ X->index = I;\
+ X->child[0] = X->child[1] = 0;\
+ if (!treemap_is_marked(M, I)) {\
+ mark_treemap(M, I);\
+ *H = X;\
+ X->parent = (tchunkptr)H;\
+ X->fd = X->bk = X;\
+ }\
+ else {\
+ tchunkptr T = *H;\
+ size_t K = S << leftshift_for_tree_index(I);\
+ for (;;) {\
+ if (chunksize(T) != S) {\
+ tchunkptr* C = &(T->child[(K >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]);\
+ K <<= 1;\
+ if (*C != 0)\
+ T = *C;\
+ else if (RTCHECK(ok_address(M, C))) {\
+ *C = X;\
+ X->parent = T;\
+ X->fd = X->bk = X;\
+ break;\
+ }\
+ else {\
+ CORRUPTION_ERROR_ACTION(M);\
+ break;\
+ }\
+ }\
+ else {\
+ tchunkptr F = T->fd;\
+ if (RTCHECK(ok_address(M, T) && ok_address(M, F))) {\
+ T->fd = F->bk = X;\
+ X->fd = F;\
+ X->bk = T;\
+ X->parent = 0;\
+ break;\
+ }\
+ else {\
+ CORRUPTION_ERROR_ACTION(M);\
+ break;\
+ }\
+ }\
+ }\
+ }\
+}
+
+/*
+ Unlink steps:
+
+ 1. If x is a chained node, unlink it from its same-sized fd/bk links
+ and choose its bk node as its replacement.
+ 2. If x was the last node of its size, but not a leaf node, it must
+ be replaced with a leaf node (not merely one with an open left or
+ right), to make sure that lefts and rights of descendents
+ correspond properly to bit masks. We use the rightmost descendent
+ of x. We could use any other leaf, but this is easy to locate and
+ tends to counteract removal of leftmosts elsewhere, and so keeps
+ paths shorter than minimally guaranteed. This doesn't loop much
+ because on average a node in a tree is near the bottom.
+ 3. If x is the base of a chain (i.e., has parent links) relink
+ x's parent and children to x's replacement (or null if none).
+*/
+
+#define unlink_large_chunk(M, X) {\
+ tchunkptr XP = X->parent;\
+ tchunkptr R;\
+ if (X->bk != X) {\
+ tchunkptr F = X->fd;\
+ R = X->bk;\
+ if (RTCHECK(ok_address(M, F) && F->bk == X && R->fd == X)) {\
+ F->bk = R;\
+ R->fd = F;\
+ }\
+ else {\
+ CORRUPTION_ERROR_ACTION(M);\
+ }\
+ }\
+ else {\
+ tchunkptr* RP;\
+ if (((R = *(RP = &(X->child[1]))) != 0) ||\
+ ((R = *(RP = &(X->child[0]))) != 0)) {\
+ tchunkptr* CP;\
+ while ((*(CP = &(R->child[1])) != 0) ||\
+ (*(CP = &(R->child[0])) != 0)) {\
+ R = *(RP = CP);\
+ }\
+ if (RTCHECK(ok_address(M, RP)))\
+ *RP = 0;\
+ else {\
+ CORRUPTION_ERROR_ACTION(M);\
+ }\
+ }\
+ }\
+ if (XP != 0) {\
+ tbinptr* H = treebin_at(M, X->index);\
+ if (X == *H) {\
+ if ((*H = R) == 0) \
+ clear_treemap(M, X->index);\
+ }\
+ else if (RTCHECK(ok_address(M, XP))) {\
+ if (XP->child[0] == X) \
+ XP->child[0] = R;\
+ else \
+ XP->child[1] = R;\
+ }\
+ else\
+ CORRUPTION_ERROR_ACTION(M);\
+ if (R != 0) {\
+ if (RTCHECK(ok_address(M, R))) {\
+ tchunkptr C0, C1;\
+ R->parent = XP;\
+ if ((C0 = X->child[0]) != 0) {\
+ if (RTCHECK(ok_address(M, C0))) {\
+ R->child[0] = C0;\
+ C0->parent = R;\
+ }\
+ else\
+ CORRUPTION_ERROR_ACTION(M);\
+ }\
+ if ((C1 = X->child[1]) != 0) {\
+ if (RTCHECK(ok_address(M, C1))) {\
+ R->child[1] = C1;\
+ C1->parent = R;\
+ }\
+ else\
+ CORRUPTION_ERROR_ACTION(M);\
+ }\
+ }\
+ else\
+ CORRUPTION_ERROR_ACTION(M);\
+ }\
+ }\
+}
+
+/* Relays to large vs small bin operations */
+
+#define insert_chunk(M, P, S)\
+ if (is_small(S)) insert_small_chunk(M, P, S)\
+ else { tchunkptr TP = (tchunkptr)(P); insert_large_chunk(M, TP, S); }
+
+#define unlink_chunk(M, P, S)\
+ if (is_small(S)) unlink_small_chunk(M, P, S)\
+ else { tchunkptr TP = (tchunkptr)(P); unlink_large_chunk(M, TP); }
+
+
+/* Relays to internal calls to malloc/free from realloc, memalign etc */
+
+#if ONLY_MSPACES
+#define internal_malloc(m, b) mspace_malloc(m, b)
+#define internal_free(m, mem) mspace_free(m,mem);
+#else /* ONLY_MSPACES */
+#if MSPACES
+#define internal_malloc(m, b)\
+ ((m == gm)? dlmalloc(b) : mspace_malloc(m, b))
+#define internal_free(m, mem)\
+ if (m == gm) dlfree(mem); else mspace_free(m,mem);
+#else /* MSPACES */
+#define internal_malloc(m, b) dlmalloc(b)
+#define internal_free(m, mem) dlfree(mem)
+#endif /* MSPACES */
+#endif /* ONLY_MSPACES */
+
+/* ----------------------- Direct-mmapping chunks ----------------------- */
+
+/*
+ Directly mmapped chunks are set up with an offset to the start of
+ the mmapped region stored in the prev_foot field of the chunk. This
+ allows reconstruction of the required argument to MUNMAP when freed,
+ and also allows adjustment of the returned chunk to meet alignment
+ requirements (especially in memalign).
+*/
+
+/* Malloc using mmap */
+static void* mmap_alloc(mstate m, size_t nb) {
+ size_t mmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
+ if (m->footprint_limit != 0) {
+ size_t fp = m->footprint + mmsize;
+ if (fp <= m->footprint || fp > m->footprint_limit)
+ return 0;
+ }
+ if (mmsize > nb) { /* Check for wrap around 0 */
+ char* mm = (char*)(CALL_DIRECT_MMAP(mmsize));
+ if (mm != CMFAIL) {
+ size_t offset = align_offset(chunk2mem(mm));
+ size_t psize = mmsize - offset - MMAP_FOOT_PAD;
+ mchunkptr p = (mchunkptr)(mm + offset);
+ p->prev_foot = offset;
+ p->head = psize;
+ mark_inuse_foot(m, p, psize);
+ chunk_plus_offset(p, psize)->head = FENCEPOST_HEAD;
+ chunk_plus_offset(p, psize+SIZE_T_SIZE)->head = 0;
+
+ if (m->least_addr == 0 || mm < m->least_addr)
+ m->least_addr = mm;
+ if ((m->footprint += mmsize) > m->max_footprint)
+ m->max_footprint = m->footprint;
+ assert(is_aligned(chunk2mem(p)));
+ check_mmapped_chunk(m, p);
+ return chunk2mem(p);
+ }
+ }
+ return 0;
+}
+
+/* Realloc using mmap */
+static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb, int flags) {
+ size_t oldsize = chunksize(oldp);
+ (void)flags; /* placate people compiling -Wunused */
+ if (is_small(nb)) /* Can't shrink mmap regions below small size */
+ return 0;
+ /* Keep old chunk if big enough but not too big */
+ if (oldsize >= nb + SIZE_T_SIZE &&
+ (oldsize - nb) <= (mparams.granularity << 1))
+ return oldp;
+ else {
+ size_t offset = oldp->prev_foot;
+ size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD;
+ size_t newmmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
+ char* cp = (char*)CALL_MREMAP((char*)oldp - offset,
+ oldmmsize, newmmsize, flags);
+ if (cp != CMFAIL) {
+ mchunkptr newp = (mchunkptr)(cp + offset);
+ size_t psize = newmmsize - offset - MMAP_FOOT_PAD;
+ newp->head = psize;
+ mark_inuse_foot(m, newp, psize);
+ chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD;
+ chunk_plus_offset(newp, psize+SIZE_T_SIZE)->head = 0;
+
+ if (cp < m->least_addr)
+ m->least_addr = cp;
+ if ((m->footprint += newmmsize - oldmmsize) > m->max_footprint)
+ m->max_footprint = m->footprint;
+ check_mmapped_chunk(m, newp);
+ return newp;
+ }
+ }
+ return 0;
+}
+
+
+/* -------------------------- mspace management -------------------------- */
+
+/* Initialize top chunk and its size */
+static void init_top(mstate m, mchunkptr p, size_t psize) {
+ /* Ensure alignment */
+ size_t offset = align_offset(chunk2mem(p));
+ p = (mchunkptr)((char*)p + offset);
+ psize -= offset;
+
+ m->top = p;
+ m->topsize = psize;
+ p->head = psize | PINUSE_BIT;
+ /* set size of fake trailing chunk holding overhead space only once */
+ chunk_plus_offset(p, psize)->head = TOP_FOOT_SIZE;
+ m->trim_check = mparams.trim_threshold; /* reset on each update */
+}
+
+/* Initialize bins for a new mstate that is otherwise zeroed out */
+static void init_bins(mstate m) {
+ /* Establish circular links for smallbins */
+ bindex_t i;
+ for (i = 0; i < NSMALLBINS; ++i) {
+ sbinptr bin = smallbin_at(m,i);
+ bin->fd = bin->bk = bin;
+ }
+}
+
+#if PROCEED_ON_ERROR
+
+/* default corruption action */
+static void reset_on_error(mstate m) {
+ int i;
+ ++malloc_corruption_error_count;
+ /* Reinitialize fields to forget about all memory */
+ m->smallmap = m->treemap = 0;
+ m->dvsize = m->topsize = 0;
+ m->seg.base = 0;
+ m->seg.size = 0;
+ m->seg.next = 0;
+ m->top = m->dv = 0;
+ for (i = 0; i < NTREEBINS; ++i)
+ *treebin_at(m, i) = 0;
+ init_bins(m);
+}
+#endif /* PROCEED_ON_ERROR */
+
+/* Allocate chunk and prepend remainder with chunk in successor base. */
+static void* prepend_alloc(mstate m, char* newbase, char* oldbase,
+ size_t nb) {
+ mchunkptr p = align_as_chunk(newbase);
+ mchunkptr oldfirst = align_as_chunk(oldbase);
+ size_t psize = (char*)oldfirst - (char*)p;
+ mchunkptr q = chunk_plus_offset(p, nb);
+ size_t qsize = psize - nb;
+ set_size_and_pinuse_of_inuse_chunk(m, p, nb);
+
+ assert((char*)oldfirst > (char*)q);
+ assert(pinuse(oldfirst));
+ assert(qsize >= MIN_CHUNK_SIZE);
+
+ /* consolidate remainder with first chunk of old base */
+ if (oldfirst == m->top) {
+ size_t tsize = m->topsize += qsize;
+ m->top = q;
+ q->head = tsize | PINUSE_BIT;
+ check_top_chunk(m, q);
+ }
+ else if (oldfirst == m->dv) {
+ size_t dsize = m->dvsize += qsize;
+ m->dv = q;
+ set_size_and_pinuse_of_free_chunk(q, dsize);
+ }
+ else {
+ if (!is_inuse(oldfirst)) {
+ size_t nsize = chunksize(oldfirst);
+ unlink_chunk(m, oldfirst, nsize);
+ oldfirst = chunk_plus_offset(oldfirst, nsize);
+ qsize += nsize;
+ }
+ set_free_with_pinuse(q, qsize, oldfirst);
+ insert_chunk(m, q, qsize);
+ check_free_chunk(m, q);
+ }
+
+ check_malloced_chunk(m, chunk2mem(p), nb);
+ return chunk2mem(p);
+}
+
+/* Add a segment to hold a new noncontiguous region */
+static void add_segment(mstate m, char* tbase, size_t tsize, flag_t mmapped) {
+ /* Determine locations and sizes of segment, fenceposts, old top */
+ char* old_top = (char*)m->top;
+ msegmentptr oldsp = segment_holding(m, old_top);
+ char* old_end = oldsp->base + oldsp->size;
+ size_t ssize = pad_request(sizeof(struct malloc_segment));
+ char* rawsp = old_end - (ssize + FOUR_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
+ size_t offset = align_offset(chunk2mem(rawsp));
+ char* asp = rawsp + offset;
+ char* csp = (asp < (old_top + MIN_CHUNK_SIZE))? old_top : asp;
+ mchunkptr sp = (mchunkptr)csp;
+ msegmentptr ss = (msegmentptr)(chunk2mem(sp));
+ mchunkptr tnext = chunk_plus_offset(sp, ssize);
+ mchunkptr p = tnext;
+ int nfences = 0;
+
+ /* reset top to new space */
+ init_top(m, (mchunkptr)tbase, tsize - TOP_FOOT_SIZE);
+
+ /* Set up segment record */
+ assert(is_aligned(ss));
+ set_size_and_pinuse_of_inuse_chunk(m, sp, ssize);
+ *ss = m->seg; /* Push current record */
+ m->seg.base = tbase;
+ m->seg.size = tsize;
+ m->seg.sflags = mmapped;
+ m->seg.next = ss;
+
+ /* Insert trailing fenceposts */
+ for (;;) {
+ mchunkptr nextp = chunk_plus_offset(p, SIZE_T_SIZE);
+ p->head = FENCEPOST_HEAD;
+ ++nfences;
+ if ((char*)(&(nextp->head)) < old_end)
+ p = nextp;
+ else
+ break;
+ }
+ assert(nfences >= 2);
+
+ /* Insert the rest of old top into a bin as an ordinary free chunk */
+ if (csp != old_top) {
+ mchunkptr q = (mchunkptr)old_top;
+ size_t psize = csp - old_top;
+ mchunkptr tn = chunk_plus_offset(q, psize);
+ set_free_with_pinuse(q, psize, tn);
+ insert_chunk(m, q, psize);
+ }
+
+ check_top_chunk(m, m->top);
+}
+
+/* -------------------------- System allocation -------------------------- */
+
+/* Get memory from system using MORECORE or MMAP */
+static void* sys_alloc(mstate m, size_t nb) {
+ char* tbase = CMFAIL;
+ size_t tsize = 0;
+ flag_t mmap_flag = 0;
+ size_t asize; /* allocation size */
+
+ ensure_initialization();
+
+ /* Directly map large chunks, but only if already initialized */
+ if (use_mmap(m) && nb >= mparams.mmap_threshold && m->topsize != 0) {
+ void* mem = mmap_alloc(m, nb);
+ if (mem != 0)
+ return mem;
+ }
+
+ asize = granularity_align(nb + SYS_ALLOC_PADDING);
+ if (asize <= nb)
+ return 0; /* wraparound */
+ if (m->footprint_limit != 0) {
+ size_t fp = m->footprint + asize;
+ if (fp <= m->footprint || fp > m->footprint_limit)
+ return 0;
+ }
+
+ /*
+ Try getting memory in any of three ways (in most-preferred to
+ least-preferred order):
+ 1. A call to MORECORE that can normally contiguously extend memory.
+ (disabled if not MORECORE_CONTIGUOUS or not HAVE_MORECORE or
+ or main space is mmapped or a previous contiguous call failed)
+ 2. A call to MMAP new space (disabled if not HAVE_MMAP).
+ Note that under the default settings, if MORECORE is unable to
+ fulfill a request, and HAVE_MMAP is true, then mmap is
+ used as a noncontiguous system allocator. This is a useful backup
+ strategy for systems with holes in address spaces -- in this case
+ sbrk cannot contiguously expand the heap, but mmap may be able to
+ find space.
+ 3. A call to MORECORE that cannot usually contiguously extend memory.
+ (disabled if not HAVE_MORECORE)
+
+ In all cases, we need to request enough bytes from system to ensure
+ we can malloc nb bytes upon success, so pad with enough space for
+ top_foot, plus alignment-pad to make sure we don't lose bytes if
+ not on boundary, and round this up to a granularity unit.
+ */
+
+ if (MORECORE_CONTIGUOUS && !use_noncontiguous(m)) {
+ char* br = CMFAIL;
+ msegmentptr ss = (m->top == 0)? 0 : segment_holding(m, (char*)m->top);
+ ACQUIRE_MALLOC_GLOBAL_LOCK();
+
+ if (ss == 0) { /* First time through or recovery */
+ char* base = (char*)CALL_MORECORE(0);
+ if (base != CMFAIL) {
+ size_t fp;
+ /* Adjust to end on a page boundary */
+ if (!is_page_aligned(base))
+ asize += (page_align((size_t)base) - (size_t)base);
+ fp = m->footprint + asize; /* recheck limits */
+ if (asize > nb && asize < HALF_MAX_SIZE_T &&
+ (m->footprint_limit == 0 ||
+ (fp > m->footprint && fp <= m->footprint_limit)) &&
+ (br = (char*)(CALL_MORECORE(asize))) == base) {
+ tbase = base;
+ tsize = asize;
+ }
+ }
+ }
+ else {
+ /* Subtract out existing available top space from MORECORE request. */
+ asize = granularity_align(nb - m->topsize + SYS_ALLOC_PADDING);
+ /* Use mem here only if it did continuously extend old space */
+ if (asize < HALF_MAX_SIZE_T &&
+ (br = (char*)(CALL_MORECORE(asize))) == ss->base+ss->size) {
+ tbase = br;
+ tsize = asize;
+ }
+ }
+
+ if (tbase == CMFAIL) { /* Cope with partial failure */
+ if (br != CMFAIL) { /* Try to use/extend the space we did get */
+ if (asize < HALF_MAX_SIZE_T &&
+ asize < nb + SYS_ALLOC_PADDING) {
+ size_t esize = granularity_align(nb + SYS_ALLOC_PADDING - asize);
+ if (esize < HALF_MAX_SIZE_T) {
+ char* end = (char*)CALL_MORECORE(esize);
+ if (end != CMFAIL)
+ asize += esize;
+ else { /* Can't use; try to release */
+ (void) CALL_MORECORE(-asize);
+ br = CMFAIL;
+ }
+ }
+ }
+ }
+ if (br != CMFAIL) { /* Use the space we did get */
+ tbase = br;
+ tsize = asize;
+ }
+ else
+ disable_contiguous(m); /* Don't try contiguous path in the future */
+ }
+
+ RELEASE_MALLOC_GLOBAL_LOCK();
+ }
+
+ if (HAVE_MMAP && tbase == CMFAIL) { /* Try MMAP */
+ char* mp = (char*)(CALL_MMAP(asize));
+ if (mp != CMFAIL) {
+ tbase = mp;
+ tsize = asize;
+ mmap_flag = USE_MMAP_BIT;
+ }
+ }
+
+ if (HAVE_MORECORE && tbase == CMFAIL) { /* Try noncontiguous MORECORE */
+ if (asize < HALF_MAX_SIZE_T) {
+ char* br = CMFAIL;
+ char* end = CMFAIL;
+ ACQUIRE_MALLOC_GLOBAL_LOCK();
+ br = (char*)(CALL_MORECORE(asize));
+ end = (char*)(CALL_MORECORE(0));
+ RELEASE_MALLOC_GLOBAL_LOCK();
+ if (br != CMFAIL && end != CMFAIL && br < end) {
+ size_t ssize = end - br;
+ if (ssize > nb + TOP_FOOT_SIZE) {
+ tbase = br;
+ tsize = ssize;
+ }
+ }
+ }
+ }
+
+ if (tbase != CMFAIL) {
+
+ if ((m->footprint += tsize) > m->max_footprint)
+ m->max_footprint = m->footprint;
+
+ if (!is_initialized(m)) { /* first-time initialization */
+ if (m->least_addr == 0 || tbase < m->least_addr)
+ m->least_addr = tbase;
+ m->seg.base = tbase;
+ m->seg.size = tsize;
+ m->seg.sflags = mmap_flag;
+ m->magic = mparams.magic;
+ m->release_checks = MAX_RELEASE_CHECK_RATE;
+ init_bins(m);
+#if !ONLY_MSPACES
+ if (is_global(m))
+ init_top(m, (mchunkptr)tbase, tsize - TOP_FOOT_SIZE);
+ else
+#endif
+ {
+ /* Offset top by embedded malloc_state */
+ mchunkptr mn = next_chunk(mem2chunk(m));
+ init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) -TOP_FOOT_SIZE);
+ }
+ }
+
+ else {
+ /* Try to merge with an existing segment */
+ msegmentptr sp = &m->seg;
+ /* Only consider most recent segment if traversal suppressed */
+ while (sp != 0 && tbase != sp->base + sp->size)
+ sp = (NO_SEGMENT_TRAVERSAL) ? 0 : sp->next;
+ if (sp != 0 &&
+ !is_extern_segment(sp) &&
+ (sp->sflags & USE_MMAP_BIT) == mmap_flag &&
+ segment_holds(sp, m->top)) { /* append */
+ sp->size += tsize;
+ init_top(m, m->top, m->topsize + tsize);
+ }
+ else {
+ if (tbase < m->least_addr)
+ m->least_addr = tbase;
+ sp = &m->seg;
+ while (sp != 0 && sp->base != tbase + tsize)
+ sp = (NO_SEGMENT_TRAVERSAL) ? 0 : sp->next;
+ if (sp != 0 &&
+ !is_extern_segment(sp) &&
+ (sp->sflags & USE_MMAP_BIT) == mmap_flag) {
+ char* oldbase = sp->base;
+ sp->base = tbase;
+ sp->size += tsize;
+ return prepend_alloc(m, tbase, oldbase, nb);
+ }
+ else
+ add_segment(m, tbase, tsize, mmap_flag);
+ }
+ }
+
+ if (nb < m->topsize) { /* Allocate from new or extended top space */
+ size_t rsize = m->topsize -= nb;
+ mchunkptr p = m->top;
+ mchunkptr r = m->top = chunk_plus_offset(p, nb);
+ r->head = rsize | PINUSE_BIT;
+ set_size_and_pinuse_of_inuse_chunk(m, p, nb);
+ check_top_chunk(m, m->top);
+ check_malloced_chunk(m, chunk2mem(p), nb);
+ return chunk2mem(p);
+ }
+ }
+
+ MALLOC_FAILURE_ACTION;
+ return 0;
+}
+
+/* ----------------------- system deallocation -------------------------- */
+
+/* Unmap and unlink any mmapped segments that don't contain used chunks */
+static size_t release_unused_segments(mstate m) {
+ size_t released = 0;
+ int nsegs = 0;
+ msegmentptr pred = &m->seg;
+ msegmentptr sp = pred->next;
+ while (sp != 0) {
+ char* base = sp->base;
+ size_t size = sp->size;
+ msegmentptr next = sp->next;
+ ++nsegs;
+ if (is_mmapped_segment(sp) && !is_extern_segment(sp)) {
+ mchunkptr p = align_as_chunk(base);
+ size_t psize = chunksize(p);
+ /* Can unmap if first chunk holds entire segment and not pinned */
+ if (!is_inuse(p) && (char*)p + psize >= base + size - TOP_FOOT_SIZE) {
+ tchunkptr tp = (tchunkptr)p;
+ assert(segment_holds(sp, (char*)sp));
+ if (p == m->dv) {
+ m->dv = 0;
+ m->dvsize = 0;
+ }
+ else {
+ unlink_large_chunk(m, tp);
+ }
+ if (CALL_MUNMAP(base, size) == 0) {
+ released += size;
+ m->footprint -= size;
+ /* unlink obsoleted record */
+ sp = pred;
+ sp->next = next;
+ }
+ else { /* back out if cannot unmap */
+ insert_large_chunk(m, tp, psize);
+ }
+ }
+ }
+ if (NO_SEGMENT_TRAVERSAL) /* scan only first segment */
+ break;
+ pred = sp;
+ sp = next;
+ }
+ /* Reset check counter */
+ m->release_checks = ((nsegs > MAX_RELEASE_CHECK_RATE)?
+ nsegs : MAX_RELEASE_CHECK_RATE);
+ return released;
+}
+
+static int sys_trim(mstate m, size_t pad) {
+ size_t released = 0;
+ ensure_initialization();
+ if (pad < MAX_REQUEST && is_initialized(m)) {
+ pad += TOP_FOOT_SIZE; /* ensure enough room for segment overhead */
+
+ if (m->topsize > pad) {
+ /* Shrink top space in granularity-size units, keeping at least one */
+ size_t unit = mparams.granularity;
+ size_t extra = ((m->topsize - pad + (unit - SIZE_T_ONE)) / unit -
+ SIZE_T_ONE) * unit;
+ msegmentptr sp = segment_holding(m, (char*)m->top);
+
+ if (!is_extern_segment(sp)) {
+ if (is_mmapped_segment(sp)) {
+ if (HAVE_MMAP &&
+ sp->size >= extra &&
+ !has_segment_link(m, sp)) { /* can't shrink if pinned */
+ size_t newsize = sp->size - extra;
+ /* Prefer mremap, fall back to munmap */
+ if ((CALL_MREMAP(sp->base, sp->size, newsize, 0) != MFAIL) ||
+ (CALL_MUNMAP(sp->base + newsize, extra) == 0)) {
+ released = extra;
+ }
+ }
+ }
+ else if (HAVE_MORECORE) {
+ if (extra >= HALF_MAX_SIZE_T) /* Avoid wrapping negative */
+ extra = (HALF_MAX_SIZE_T) + SIZE_T_ONE - unit;
+ ACQUIRE_MALLOC_GLOBAL_LOCK();
+ {
+ /* Make sure end of memory is where we last set it. */
+ char* old_br = (char*)(CALL_MORECORE(0));
+ if (old_br == sp->base + sp->size) {
+ char* rel_br = (char*)(CALL_MORECORE(-extra));
+ char* new_br = (char*)(CALL_MORECORE(0));
+ if (rel_br != CMFAIL && new_br < old_br)
+ released = old_br - new_br;
+ }
+ }
+ RELEASE_MALLOC_GLOBAL_LOCK();
+ }
+ }
+
+ if (released != 0) {
+ sp->size -= released;
+ m->footprint -= released;
+ init_top(m, m->top, m->topsize - released);
+ check_top_chunk(m, m->top);
+ }
+ }
+
+ /* Unmap any unused mmapped segments */
+ if (HAVE_MMAP)
+ released += release_unused_segments(m);
+
+ /* On failure, disable autotrim to avoid repeated failed future calls */
+ if (released == 0 && m->topsize > m->trim_check)
+ m->trim_check = MAX_SIZE_T;
+ }
+
+ return (released != 0)? 1 : 0;
+}
+
+/* Consolidate and bin a chunk. Differs from exported versions
+ of free mainly in that the chunk need not be marked as inuse.
+*/
+static void dispose_chunk(mstate m, mchunkptr p, size_t psize) {
+ mchunkptr next = chunk_plus_offset(p, psize);
+ if (!pinuse(p)) {
+ mchunkptr prev;
+ size_t prevsize = p->prev_foot;
+ if (is_mmapped(p)) {
+ psize += prevsize + MMAP_FOOT_PAD;
+ if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
+ m->footprint -= psize;
+ return;
+ }
+ prev = chunk_minus_offset(p, prevsize);
+ psize += prevsize;
+ p = prev;
+ if (RTCHECK(ok_address(m, prev))) { /* consolidate backward */
+ if (p != m->dv) {
+ unlink_chunk(m, p, prevsize);
+ }
+ else if ((next->head & INUSE_BITS) == INUSE_BITS) {
+ m->dvsize = psize;
+ set_free_with_pinuse(p, psize, next);
+ return;
+ }
+ }
+ else {
+ CORRUPTION_ERROR_ACTION(m);
+ return;
+ }
+ }
+ if (RTCHECK(ok_address(m, next))) {
+ if (!cinuse(next)) { /* consolidate forward */
+ if (next == m->top) {
+ size_t tsize = m->topsize += psize;
+ m->top = p;
+ p->head = tsize | PINUSE_BIT;
+ if (p == m->dv) {
+ m->dv = 0;
+ m->dvsize = 0;
+ }
+ return;
+ }
+ else if (next == m->dv) {
+ size_t dsize = m->dvsize += psize;
+ m->dv = p;
+ set_size_and_pinuse_of_free_chunk(p, dsize);
+ return;
+ }
+ else {
+ size_t nsize = chunksize(next);
+ psize += nsize;
+ unlink_chunk(m, next, nsize);
+ set_size_and_pinuse_of_free_chunk(p, psize);
+ if (p == m->dv) {
+ m->dvsize = psize;
+ return;
+ }
+ }
+ }
+ else {
+ set_free_with_pinuse(p, psize, next);
+ }
+ insert_chunk(m, p, psize);
+ }
+ else {
+ CORRUPTION_ERROR_ACTION(m);
+ }
+}
+
+/* ---------------------------- malloc --------------------------- */
+
+/* allocate a large request from the best fitting chunk in a treebin */
+static void* tmalloc_large(mstate m, size_t nb) {
+ tchunkptr v = 0;
+ size_t rsize = -nb; /* Unsigned negation */
+ tchunkptr t;
+ bindex_t idx;
+ compute_tree_index(nb, idx);
+ if ((t = *treebin_at(m, idx)) != 0) {
+ /* Traverse tree for this bin looking for node with size == nb */
+ size_t sizebits = nb << leftshift_for_tree_index(idx);
+ tchunkptr rst = 0; /* The deepest untaken right subtree */
+ for (;;) {
+ tchunkptr rt;
+ size_t trem = chunksize(t) - nb;
+ if (trem < rsize) {
+ v = t;
+ if ((rsize = trem) == 0)
+ break;
+ }
+ rt = t->child[1];
+ t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1];
+ if (rt != 0 && rt != t)
+ rst = rt;
+ if (t == 0) {
+ t = rst; /* set t to least subtree holding sizes > nb */
+ break;
+ }
+ sizebits <<= 1;
+ }
+ }
+ if (t == 0 && v == 0) { /* set t to root of next non-empty treebin */
+ binmap_t leftbits = left_bits(idx2bit(idx)) & m->treemap;
+ if (leftbits != 0) {
+ bindex_t i;
+ binmap_t leastbit = least_bit(leftbits);
+ compute_bit2idx(leastbit, i);
+ t = *treebin_at(m, i);
+ }
+ }
+
+ while (t != 0) { /* find smallest of tree or subtree */
+ size_t trem = chunksize(t) - nb;
+ if (trem < rsize) {
+ rsize = trem;
+ v = t;
+ }
+ t = leftmost_child(t);
+ }
+
+ /* If dv is a better fit, return 0 so malloc will use it */
+ if (v != 0 && rsize < (size_t)(m->dvsize - nb)) {
+ if (RTCHECK(ok_address(m, v))) { /* split */
+ mchunkptr r = chunk_plus_offset(v, nb);
+ assert(chunksize(v) == rsize + nb);
+ if (RTCHECK(ok_next(v, r))) {
+ unlink_large_chunk(m, v);
+ if (rsize < MIN_CHUNK_SIZE)
+ set_inuse_and_pinuse(m, v, (rsize + nb));
+ else {
+ set_size_and_pinuse_of_inuse_chunk(m, v, nb);
+ set_size_and_pinuse_of_free_chunk(r, rsize);
+ insert_chunk(m, r, rsize);
+ }
+ return chunk2mem(v);
+ }
+ }
+ CORRUPTION_ERROR_ACTION(m);
+ }
+ return 0;
+}
+
+/* allocate a small request from the best fitting chunk in a treebin */
+static void* tmalloc_small(mstate m, size_t nb) {
+ tchunkptr t, v;
+ size_t rsize;
+ bindex_t i;
+ binmap_t leastbit = least_bit(m->treemap);
+ compute_bit2idx(leastbit, i);
+ v = t = *treebin_at(m, i);
+ rsize = chunksize(t) - nb;
+
+ while ((t = leftmost_child(t)) != 0) {
+ size_t trem = chunksize(t) - nb;
+ if (trem < rsize) {
+ rsize = trem;
+ v = t;
+ }
+ }
+
+ if (RTCHECK(ok_address(m, v))) {
+ mchunkptr r = chunk_plus_offset(v, nb);
+ assert(chunksize(v) == rsize + nb);
+ if (RTCHECK(ok_next(v, r))) {
+ unlink_large_chunk(m, v);
+ if (rsize < MIN_CHUNK_SIZE)
+ set_inuse_and_pinuse(m, v, (rsize + nb));
+ else {
+ set_size_and_pinuse_of_inuse_chunk(m, v, nb);
+ set_size_and_pinuse_of_free_chunk(r, rsize);
+ replace_dv(m, r, rsize);
+ }
+ return chunk2mem(v);
+ }
+ }
+
+ CORRUPTION_ERROR_ACTION(m);
+ return 0;
+}
+
+#if !ONLY_MSPACES
+
+void* dlmalloc(size_t bytes) {
+ /*
+ Basic algorithm:
+ If a small request (< 256 bytes minus per-chunk overhead):
+ 1. If one exists, use a remainderless chunk in associated smallbin.
+ (Remainderless means that there are too few excess bytes to
+ represent as a chunk.)
+ 2. If it is big enough, use the dv chunk, which is normally the
+ chunk adjacent to the one used for the most recent small request.
+ 3. If one exists, split the smallest available chunk in a bin,
+ saving remainder in dv.
+ 4. If it is big enough, use the top chunk.
+ 5. If available, get memory from system and use it
+ Otherwise, for a large request:
+ 1. Find the smallest available binned chunk that fits, and use it
+ if it is better fitting than dv chunk, splitting if necessary.
+ 2. If better fitting than any binned chunk, use the dv chunk.
+ 3. If it is big enough, use the top chunk.
+ 4. If request size >= mmap threshold, try to directly mmap this chunk.
+ 5. If available, get memory from system and use it
+
+ The ugly goto's here ensure that postaction occurs along all paths.
+ */
+
+#if USE_LOCKS
+ ensure_initialization(); /* initialize in sys_alloc if not using locks */
+#endif
+
+ if (!PREACTION(gm)) {
+ void* mem;
+ size_t nb;
+ if (bytes <= MAX_SMALL_REQUEST) {
+ bindex_t idx;
+ binmap_t smallbits;
+ nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes);
+ idx = small_index(nb);
+ smallbits = gm->smallmap >> idx;
+
+ if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */
+ mchunkptr b, p;
+ idx += ~smallbits & 1; /* Uses next bin if idx empty */
+ b = smallbin_at(gm, idx);
+ p = b->fd;
+ assert(chunksize(p) == small_index2size(idx));
+ unlink_first_small_chunk(gm, b, p, idx);
+ set_inuse_and_pinuse(gm, p, small_index2size(idx));
+ mem = chunk2mem(p);
+ check_malloced_chunk(gm, mem, nb);
+ goto postaction;
+ }
+
+ else if (nb > gm->dvsize) {
+ if (smallbits != 0) { /* Use chunk in next nonempty smallbin */
+ mchunkptr b, p, r;
+ size_t rsize;
+ bindex_t i;
+ binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx));
+ binmap_t leastbit = least_bit(leftbits);
+ compute_bit2idx(leastbit, i);
+ b = smallbin_at(gm, i);
+ p = b->fd;
+ assert(chunksize(p) == small_index2size(i));
+ unlink_first_small_chunk(gm, b, p, i);
+ rsize = small_index2size(i) - nb;
+ /* Fit here cannot be remainderless if 4byte sizes */
+ if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
+ set_inuse_and_pinuse(gm, p, small_index2size(i));
+ else {
+ set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
+ r = chunk_plus_offset(p, nb);
+ set_size_and_pinuse_of_free_chunk(r, rsize);
+ replace_dv(gm, r, rsize);
+ }
+ mem = chunk2mem(p);
+ check_malloced_chunk(gm, mem, nb);
+ goto postaction;
+ }
+
+ else if (gm->treemap != 0 && (mem = tmalloc_small(gm, nb)) != 0) {
+ check_malloced_chunk(gm, mem, nb);
+ goto postaction;
+ }
+ }
+ }
+ else if (bytes >= MAX_REQUEST)
+ nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
+ else {
+ nb = pad_request(bytes);
+ if (gm->treemap != 0 && (mem = tmalloc_large(gm, nb)) != 0) {
+ check_malloced_chunk(gm, mem, nb);
+ goto postaction;
+ }
+ }
+
+ if (nb <= gm->dvsize) {
+ size_t rsize = gm->dvsize - nb;
+ mchunkptr p = gm->dv;
+ if (rsize >= MIN_CHUNK_SIZE) { /* split dv */
+ mchunkptr r = gm->dv = chunk_plus_offset(p, nb);
+ gm->dvsize = rsize;
+ set_size_and_pinuse_of_free_chunk(r, rsize);
+ set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
+ }
+ else { /* exhaust dv */
+ size_t dvs = gm->dvsize;
+ gm->dvsize = 0;
+ gm->dv = 0;
+ set_inuse_and_pinuse(gm, p, dvs);
+ }
+ mem = chunk2mem(p);
+ check_malloced_chunk(gm, mem, nb);
+ goto postaction;
+ }
+
+ else if (nb < gm->topsize) { /* Split top */
+ size_t rsize = gm->topsize -= nb;
+ mchunkptr p = gm->top;
+ mchunkptr r = gm->top = chunk_plus_offset(p, nb);
+ r->head = rsize | PINUSE_BIT;
+ set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
+ mem = chunk2mem(p);
+ check_top_chunk(gm, gm->top);
+ check_malloced_chunk(gm, mem, nb);
+ goto postaction;
+ }
+
+ mem = sys_alloc(gm, nb);
+
+ postaction:
+ POSTACTION(gm);
+ return mem;
+ }
+
+ return 0;
+}
+
+/* ---------------------------- free --------------------------- */
+
+void dlfree(void* mem) {
+ /*
+ Consolidate freed chunks with preceeding or succeeding bordering
+ free chunks, if they exist, and then place in a bin. Intermixed
+ with special cases for top, dv, mmapped chunks, and usage errors.
+ */
+
+ if (mem != 0) {
+ mchunkptr p = mem2chunk(mem);
+#if FOOTERS
+ mstate fm = get_mstate_for(p);
+ if (!ok_magic(fm)) {
+ USAGE_ERROR_ACTION(fm, p);
+ return;
+ }
+#else /* FOOTERS */
+#define fm gm
+#endif /* FOOTERS */
+ if (!PREACTION(fm)) {
+ check_inuse_chunk(fm, p);
+ if (RTCHECK(ok_address(fm, p) && ok_inuse(p))) {
+ size_t psize = chunksize(p);
+ mchunkptr next = chunk_plus_offset(p, psize);
+ if (!pinuse(p)) {
+ size_t prevsize = p->prev_foot;
+ if (is_mmapped(p)) {
+ psize += prevsize + MMAP_FOOT_PAD;
+ if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
+ fm->footprint -= psize;
+ goto postaction;
+ }
+ else {
+ mchunkptr prev = chunk_minus_offset(p, prevsize);
+ psize += prevsize;
+ p = prev;
+ if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */
+ if (p != fm->dv) {
+ unlink_chunk(fm, p, prevsize);
+ }
+ else if ((next->head & INUSE_BITS) == INUSE_BITS) {
+ fm->dvsize = psize;
+ set_free_with_pinuse(p, psize, next);
+ goto postaction;
+ }
+ }
+ else
+ goto erroraction;
+ }
+ }
+
+ if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
+ if (!cinuse(next)) { /* consolidate forward */
+ if (next == fm->top) {
+ size_t tsize = fm->topsize += psize;
+ fm->top = p;
+ p->head = tsize | PINUSE_BIT;
+ if (p == fm->dv) {
+ fm->dv = 0;
+ fm->dvsize = 0;
+ }
+ if (should_trim(fm, tsize))
+ sys_trim(fm, 0);
+ goto postaction;
+ }
+ else if (next == fm->dv) {
+ size_t dsize = fm->dvsize += psize;
+ fm->dv = p;
+ set_size_and_pinuse_of_free_chunk(p, dsize);
+ goto postaction;
+ }
+ else {
+ size_t nsize = chunksize(next);
+ psize += nsize;
+ unlink_chunk(fm, next, nsize);
+ set_size_and_pinuse_of_free_chunk(p, psize);
+ if (p == fm->dv) {
+ fm->dvsize = psize;
+ goto postaction;
+ }
+ }
+ }
+ else
+ set_free_with_pinuse(p, psize, next);
+
+ if (is_small(psize)) {
+ insert_small_chunk(fm, p, psize);
+ check_free_chunk(fm, p);
+ }
+ else {
+ tchunkptr tp = (tchunkptr)p;
+ insert_large_chunk(fm, tp, psize);
+ check_free_chunk(fm, p);
+ if (--fm->release_checks == 0)
+ release_unused_segments(fm);
+ }
+ goto postaction;
+ }
+ }
+ erroraction:
+ USAGE_ERROR_ACTION(fm, p);
+ postaction:
+ POSTACTION(fm);
+ }
+ }
+#if !FOOTERS
+#undef fm
+#endif /* FOOTERS */
+}
+
+void* dlcalloc(size_t n_elements, size_t elem_size) {
+ void* mem;
+ size_t req = 0;
+ if (n_elements != 0) {
+ req = n_elements * elem_size;
+ if (((n_elements | elem_size) & ~(size_t)0xffff) &&
+ (req / n_elements != elem_size))
+ req = MAX_SIZE_T; /* force downstream failure on overflow */
+ }
+ mem = dlmalloc(req);
+ if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
+ memset(mem, 0, req);
+ return mem;
+}
+
+#endif /* !ONLY_MSPACES */
+
+/* ------------ Internal support for realloc, memalign, etc -------------- */
+
+/* Try to realloc; only in-place unless can_move true */
+static mchunkptr try_realloc_chunk(mstate m, mchunkptr p, size_t nb,
+ int can_move) {
+ mchunkptr newp = 0;
+ size_t oldsize = chunksize(p);
+ mchunkptr next = chunk_plus_offset(p, oldsize);
+ if (RTCHECK(ok_address(m, p) && ok_inuse(p) &&
+ ok_next(p, next) && ok_pinuse(next))) {
+ if (is_mmapped(p)) {
+ newp = mmap_resize(m, p, nb, can_move);
+ }
+ else if (oldsize >= nb) { /* already big enough */
+ size_t rsize = oldsize - nb;
+ if (rsize >= MIN_CHUNK_SIZE) { /* split off remainder */
+ mchunkptr r = chunk_plus_offset(p, nb);
+ set_inuse(m, p, nb);
+ set_inuse(m, r, rsize);
+ dispose_chunk(m, r, rsize);
+ }
+ newp = p;
+ }
+ else if (next == m->top) { /* extend into top */
+ if (oldsize + m->topsize > nb) {
+ size_t newsize = oldsize + m->topsize;
+ size_t newtopsize = newsize - nb;
+ mchunkptr newtop = chunk_plus_offset(p, nb);
+ set_inuse(m, p, nb);
+ newtop->head = newtopsize |PINUSE_BIT;
+ m->top = newtop;
+ m->topsize = newtopsize;
+ newp = p;
+ }
+ }
+ else if (next == m->dv) { /* extend into dv */
+ size_t dvs = m->dvsize;
+ if (oldsize + dvs >= nb) {
+ size_t dsize = oldsize + dvs - nb;
+ if (dsize >= MIN_CHUNK_SIZE) {
+ mchunkptr r = chunk_plus_offset(p, nb);
+ mchunkptr n = chunk_plus_offset(r, dsize);
+ set_inuse(m, p, nb);
+ set_size_and_pinuse_of_free_chunk(r, dsize);
+ clear_pinuse(n);
+ m->dvsize = dsize;
+ m->dv = r;
+ }
+ else { /* exhaust dv */
+ size_t newsize = oldsize + dvs;
+ set_inuse(m, p, newsize);
+ m->dvsize = 0;
+ m->dv = 0;
+ }
+ newp = p;
+ }
+ }
+ else if (!cinuse(next)) { /* extend into next free chunk */
+ size_t nextsize = chunksize(next);
+ if (oldsize + nextsize >= nb) {
+ size_t rsize = oldsize + nextsize - nb;
+ unlink_chunk(m, next, nextsize);
+ if (rsize < MIN_CHUNK_SIZE) {
+ size_t newsize = oldsize + nextsize;
+ set_inuse(m, p, newsize);
+ }
+ else {
+ mchunkptr r = chunk_plus_offset(p, nb);
+ set_inuse(m, p, nb);
+ set_inuse(m, r, rsize);
+ dispose_chunk(m, r, rsize);
+ }
+ newp = p;
+ }
+ }
+ }
+ else {
+ USAGE_ERROR_ACTION(m, oldmem);
+ }
+ return newp;
+}
+
+static void* internal_memalign(mstate m, size_t alignment, size_t bytes) {
+ void* mem = 0;
+ if (alignment < MIN_CHUNK_SIZE) /* must be at least a minimum chunk size */
+ alignment = MIN_CHUNK_SIZE;
+ if ((alignment & (alignment-SIZE_T_ONE)) != 0) {/* Ensure a power of 2 */
+ size_t a = MALLOC_ALIGNMENT << 1;
+ while (a < alignment) a <<= 1;
+ alignment = a;
+ }
+ if (bytes >= MAX_REQUEST - alignment) {
+ if (m != 0) { /* Test isn't needed but avoids compiler warning */
+ MALLOC_FAILURE_ACTION;
+ }
+ }
+ else {
+ size_t nb = request2size(bytes);
+ size_t req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD;
+ mem = internal_malloc(m, req);
+ if (mem != 0) {
+ mchunkptr p = mem2chunk(mem);
+ if (PREACTION(m))
+ return 0;
+ if ((((size_t)(mem)) & (alignment - 1)) != 0) { /* misaligned */
+ /*
+ Find an aligned spot inside chunk. Since we need to give
+ back leading space in a chunk of at least MIN_CHUNK_SIZE, if
+ the first calculation places us at a spot with less than
+ MIN_CHUNK_SIZE leader, we can move to the next aligned spot.
+ We've allocated enough total room so that this is always
+ possible.
+ */
+ char* br = (char*)mem2chunk((size_t)(((size_t)((char*)mem + alignment -
+ SIZE_T_ONE)) &
+ -alignment));
+ char* pos = ((size_t)(br - (char*)(p)) >= MIN_CHUNK_SIZE)?
+ br : br+alignment;
+ mchunkptr newp = (mchunkptr)pos;
+ size_t leadsize = pos - (char*)(p);
+ size_t newsize = chunksize(p) - leadsize;
+
+ if (is_mmapped(p)) { /* For mmapped chunks, just adjust offset */
+ newp->prev_foot = p->prev_foot + leadsize;
+ newp->head = newsize;
+ }
+ else { /* Otherwise, give back leader, use the rest */
+ set_inuse(m, newp, newsize);
+ set_inuse(m, p, leadsize);
+ dispose_chunk(m, p, leadsize);
+ }
+ p = newp;
+ }
+
+ /* Give back spare room at the end */
+ if (!is_mmapped(p)) {
+ size_t size = chunksize(p);
+ if (size > nb + MIN_CHUNK_SIZE) {
+ size_t remainder_size = size - nb;
+ mchunkptr remainder = chunk_plus_offset(p, nb);
+ set_inuse(m, p, nb);
+ set_inuse(m, remainder, remainder_size);
+ dispose_chunk(m, remainder, remainder_size);
+ }
+ }
+
+ mem = chunk2mem(p);
+ assert (chunksize(p) >= nb);
+ assert(((size_t)mem & (alignment - 1)) == 0);
+ check_inuse_chunk(m, p);
+ POSTACTION(m);
+ }
+ }
+ return mem;
+}
+
+/*
+ Common support for independent_X routines, handling
+ all of the combinations that can result.
+ The opts arg has:
+ bit 0 set if all elements are same size (using sizes[0])
+ bit 1 set if elements should be zeroed
+*/
+static void** ialloc(mstate m,
+ size_t n_elements,
+ size_t* sizes,
+ int opts,
+ void* chunks[]) {
+
+ size_t element_size; /* chunksize of each element, if all same */
+ size_t contents_size; /* total size of elements */
+ size_t array_size; /* request size of pointer array */
+ void* mem; /* malloced aggregate space */
+ mchunkptr p; /* corresponding chunk */
+ size_t remainder_size; /* remaining bytes while splitting */
+ void** marray; /* either "chunks" or malloced ptr array */
+ mchunkptr array_chunk; /* chunk for malloced ptr array */
+ flag_t was_enabled; /* to disable mmap */
+ size_t size;
+ size_t i;
+
+ ensure_initialization();
+ /* compute array length, if needed */
+ if (chunks != 0) {
+ if (n_elements == 0)
+ return chunks; /* nothing to do */
+ marray = chunks;
+ array_size = 0;
+ }
+ else {
+ /* if empty req, must still return chunk representing empty array */
+ if (n_elements == 0)
+ return (void**)internal_malloc(m, 0);
+ marray = 0;
+ array_size = request2size(n_elements * (sizeof(void*)));
+ }
+
+ /* compute total element size */
+ if (opts & 0x1) { /* all-same-size */
+ element_size = request2size(*sizes);
+ contents_size = n_elements * element_size;
+ }
+ else { /* add up all the sizes */
+ element_size = 0;
+ contents_size = 0;
+ for (i = 0; i != n_elements; ++i)
+ contents_size += request2size(sizes[i]);
+ }
+
+ size = contents_size + array_size;
+
+ /*
+ Allocate the aggregate chunk. First disable direct-mmapping so
+ malloc won't use it, since we would not be able to later
+ free/realloc space internal to a segregated mmap region.
+ */
+ was_enabled = use_mmap(m);
+ disable_mmap(m);
+ mem = internal_malloc(m, size - CHUNK_OVERHEAD);
+ if (was_enabled)
+ enable_mmap(m);
+ if (mem == 0)
+ return 0;
+
+ if (PREACTION(m)) return 0;
+ p = mem2chunk(mem);
+ remainder_size = chunksize(p);
+
+ assert(!is_mmapped(p));
+
+ if (opts & 0x2) { /* optionally clear the elements */
+ memset((size_t*)mem, 0, remainder_size - SIZE_T_SIZE - array_size);
+ }
+
+ /* If not provided, allocate the pointer array as final part of chunk */
+ if (marray == 0) {
+ size_t array_chunk_size;
+ array_chunk = chunk_plus_offset(p, contents_size);
+ array_chunk_size = remainder_size - contents_size;
+ marray = (void**) (chunk2mem(array_chunk));
+ set_size_and_pinuse_of_inuse_chunk(m, array_chunk, array_chunk_size);
+ remainder_size = contents_size;
+ }
+
+ /* split out elements */
+ for (i = 0; ; ++i) {
+ marray[i] = chunk2mem(p);
+ if (i != n_elements-1) {
+ if (element_size != 0)
+ size = element_size;
+ else
+ size = request2size(sizes[i]);
+ remainder_size -= size;
+ set_size_and_pinuse_of_inuse_chunk(m, p, size);
+ p = chunk_plus_offset(p, size);
+ }
+ else { /* the final element absorbs any overallocation slop */
+ set_size_and_pinuse_of_inuse_chunk(m, p, remainder_size);
+ break;
+ }
+ }
+
+#if DEBUG
+ if (marray != chunks) {
+ /* final element must have exactly exhausted chunk */
+ if (element_size != 0) {
+ assert(remainder_size == element_size);
+ }
+ else {
+ assert(remainder_size == request2size(sizes[i]));
+ }
+ check_inuse_chunk(m, mem2chunk(marray));
+ }
+ for (i = 0; i != n_elements; ++i)
+ check_inuse_chunk(m, mem2chunk(marray[i]));
+
+#endif /* DEBUG */
+
+ POSTACTION(m);
+ return marray;
+}
+
+/* Try to free all pointers in the given array.
+ Note: this could be made faster, by delaying consolidation,
+ at the price of disabling some user integrity checks, We
+ still optimize some consolidations by combining adjacent
+ chunks before freeing, which will occur often if allocated
+ with ialloc or the array is sorted.
+*/
+static size_t internal_bulk_free(mstate m, void* array[], size_t nelem) {
+ size_t unfreed = 0;
+ if (!PREACTION(m)) {
+ void** a;
+ void** fence = &(array[nelem]);
+ for (a = array; a != fence; ++a) {
+ void* mem = *a;
+ if (mem != 0) {
+ mchunkptr p = mem2chunk(mem);
+ size_t psize = chunksize(p);
+#if FOOTERS
+ if (get_mstate_for(p) != m) {
+ ++unfreed;
+ continue;
+ }
+#endif
+ check_inuse_chunk(m, p);
+ *a = 0;
+ if (RTCHECK(ok_address(m, p) && ok_inuse(p))) {
+ void ** b = a + 1; /* try to merge with next chunk */
+ mchunkptr next = next_chunk(p);
+ if (b != fence && *b == chunk2mem(next)) {
+ size_t newsize = chunksize(next) + psize;
+ set_inuse(m, p, newsize);
+ *b = chunk2mem(p);
+ }
+ else
+ dispose_chunk(m, p, psize);
+ }
+ else {
+ CORRUPTION_ERROR_ACTION(m);
+ break;
+ }
+ }
+ }
+ if (should_trim(m, m->topsize))
+ sys_trim(m, 0);
+ POSTACTION(m);
+ }
+ return unfreed;
+}
+
+/* Traversal */
+#if MALLOC_INSPECT_ALL
+static void internal_inspect_all(mstate m,
+ void(*handler)(void *start,
+ void *end,
+ size_t used_bytes,
+ void* callback_arg),
+ void* arg) {
+ if (is_initialized(m)) {
+ mchunkptr top = m->top;
+ msegmentptr s;
+ for (s = &m->seg; s != 0; s = s->next) {
+ mchunkptr q = align_as_chunk(s->base);
+ while (segment_holds(s, q) && q->head != FENCEPOST_HEAD) {
+ mchunkptr next = next_chunk(q);
+ size_t sz = chunksize(q);
+ size_t used;
+ void* start;
+ if (is_inuse(q)) {
+ used = sz - CHUNK_OVERHEAD; /* must not be mmapped */
+ start = chunk2mem(q);
+ }
+ else {
+ used = 0;
+ if (is_small(sz)) { /* offset by possible bookkeeping */
+ start = (void*)((char*)q + sizeof(malloc_chunk));
+ }
+ else {
+ start = (void*)((char*)q + sizeof(malloc_tree_chunk));
+ }
+ }
+ if (start < (void*)next) /* skip if all space is bookkeeping */
+ handler(start, next, used, arg);
+ if (q == top)
+ break;
+ q = next;
+ }
+ }
+ }
+}
+#endif /* MALLOC_INSPECT_ALL */
+
+/* ------------------ Exported realloc, memalign, etc -------------------- */
+
+#if !ONLY_MSPACES
+
+void* dlrealloc(void* oldmem, size_t bytes) {
+ void* mem = 0;
+ if (oldmem == 0) {
+ mem = dlmalloc(bytes);
+ }
+ else if (bytes >= MAX_REQUEST) {
+ MALLOC_FAILURE_ACTION;
+ }
+#ifdef REALLOC_ZERO_BYTES_FREES
+ else if (bytes == 0) {
+ dlfree(oldmem);
+ }
+#endif /* REALLOC_ZERO_BYTES_FREES */
+ else {
+ size_t nb = request2size(bytes);
+ mchunkptr oldp = mem2chunk(oldmem);
+#if ! FOOTERS
+ mstate m = gm;
+#else /* FOOTERS */
+ mstate m = get_mstate_for(oldp);
+ if (!ok_magic(m)) {
+ USAGE_ERROR_ACTION(m, oldmem);
+ return 0;
+ }
+#endif /* FOOTERS */
+ if (!PREACTION(m)) {
+ mchunkptr newp = try_realloc_chunk(m, oldp, nb, 1);
+ POSTACTION(m);
+ if (newp != 0) {
+ check_inuse_chunk(m, newp);
+ mem = chunk2mem(newp);
+ }
+ else {
+ mem = internal_malloc(m, bytes);
+ if (mem != 0) {
+ size_t oc = chunksize(oldp) - overhead_for(oldp);
+ memcpy(mem, oldmem, (oc < bytes)? oc : bytes);
+ internal_free(m, oldmem);
+ }
+ }
+ }
+ }
+ return mem;
+}
+
+void* dlrealloc_in_place(void* oldmem, size_t bytes) {
+ void* mem = 0;
+ if (oldmem != 0) {
+ if (bytes >= MAX_REQUEST) {
+ MALLOC_FAILURE_ACTION;
+ }
+ else {
+ size_t nb = request2size(bytes);
+ mchunkptr oldp = mem2chunk(oldmem);
+#if ! FOOTERS
+ mstate m = gm;
+#else /* FOOTERS */
+ mstate m = get_mstate_for(oldp);
+ if (!ok_magic(m)) {
+ USAGE_ERROR_ACTION(m, oldmem);
+ return 0;
+ }
+#endif /* FOOTERS */
+ if (!PREACTION(m)) {
+ mchunkptr newp = try_realloc_chunk(m, oldp, nb, 0);
+ POSTACTION(m);
+ if (newp == oldp) {
+ check_inuse_chunk(m, newp);
+ mem = oldmem;
+ }
+ }
+ }
+ }
+ return mem;
+}
+
+void* dlmemalign(size_t alignment, size_t bytes) {
+ if (alignment <= MALLOC_ALIGNMENT) {
+ return dlmalloc(bytes);
+ }
+ return internal_memalign(gm, alignment, bytes);
+}
+
+int dlposix_memalign(void** pp, size_t alignment, size_t bytes) {
+ void* mem = 0;
+ if (alignment == MALLOC_ALIGNMENT)
+ mem = dlmalloc(bytes);
+ else {
+ size_t d = alignment / sizeof(void*);
+ size_t r = alignment % sizeof(void*);
+ if (r != 0 || d == 0 || (d & (d-SIZE_T_ONE)) != 0)
+ return EINVAL;
+ else if (bytes >= MAX_REQUEST - alignment) {
+ if (alignment < MIN_CHUNK_SIZE)
+ alignment = MIN_CHUNK_SIZE;
+ mem = internal_memalign(gm, alignment, bytes);
+ }
+ }
+ if (mem == 0)
+ return ENOMEM;
+ else {
+ *pp = mem;
+ return 0;
+ }
+}
+
+void* dlvalloc(size_t bytes) {
+ size_t pagesz;
+ ensure_initialization();
+ pagesz = mparams.page_size;
+ return dlmemalign(pagesz, bytes);
+}
+
+void* dlpvalloc(size_t bytes) {
+ size_t pagesz;
+ ensure_initialization();
+ pagesz = mparams.page_size;
+ return dlmemalign(pagesz, (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE));
+}
+
+void** dlindependent_calloc(size_t n_elements, size_t elem_size,
+ void* chunks[]) {
+ size_t sz = elem_size; /* serves as 1-element array */
+ return ialloc(gm, n_elements, &sz, 3, chunks);
+}
+
+void** dlindependent_comalloc(size_t n_elements, size_t sizes[],
+ void* chunks[]) {
+ return ialloc(gm, n_elements, sizes, 0, chunks);
+}
+
+size_t dlbulk_free(void* array[], size_t nelem) {
+ return internal_bulk_free(gm, array, nelem);
+}
+
+#if MALLOC_INSPECT_ALL
+void dlmalloc_inspect_all(void(*handler)(void *start,
+ void *end,
+ size_t used_bytes,
+ void* callback_arg),
+ void* arg) {
+ ensure_initialization();
+ if (!PREACTION(gm)) {
+ internal_inspect_all(gm, handler, arg);
+ POSTACTION(gm);
+ }
+}
+#endif /* MALLOC_INSPECT_ALL */
+
+int dlmalloc_trim(size_t pad) {
+ int result = 0;
+ ensure_initialization();
+ if (!PREACTION(gm)) {
+ result = sys_trim(gm, pad);
+ POSTACTION(gm);
+ }
+ return result;
+}
+
+size_t dlmalloc_footprint(void) {
+ return gm->footprint;
+}
+
+size_t dlmalloc_max_footprint(void) {
+ return gm->max_footprint;
+}
+
+size_t dlmalloc_footprint_limit(void) {
+ size_t maf = gm->footprint_limit;
+ return maf == 0 ? MAX_SIZE_T : maf;
+}
+
+size_t dlmalloc_set_footprint_limit(size_t bytes) {
+ size_t result; /* invert sense of 0 */
+ if (bytes == 0)
+ result = granularity_align(1); /* Use minimal size */
+ if (bytes == MAX_SIZE_T)
+ result = 0; /* disable */
+ else
+ result = granularity_align(bytes);
+ return gm->footprint_limit = result;
+}
+
+#if !NO_MALLINFO
+struct mallinfo dlmallinfo(void) {
+ return internal_mallinfo(gm);
+}
+#endif /* NO_MALLINFO */
+
+#if !NO_MALLOC_STATS
+void dlmalloc_stats() {
+ internal_malloc_stats(gm);
+}
+#endif /* NO_MALLOC_STATS */
+
+int dlmallopt(int param_number, int value) {
+ return change_mparam(param_number, value);
+}
+
+size_t dlmalloc_usable_size(void* mem) {
+ if (mem != 0) {
+ mchunkptr p = mem2chunk(mem);
+ if (is_inuse(p))
+ return chunksize(p) - overhead_for(p);
+ }
+ return 0;
+}
+
+#endif /* !ONLY_MSPACES */
+
+/* ----------------------------- user mspaces ---------------------------- */
+
+#if MSPACES
+
+static mstate init_user_mstate(char* tbase, size_t tsize) {
+ size_t msize = pad_request(sizeof(struct malloc_state));
+ mchunkptr mn;
+ mchunkptr msp = align_as_chunk(tbase);
+ mstate m = (mstate)(chunk2mem(msp));
+ memset(m, 0, msize);
+ (void)INITIAL_LOCK(&m->mutex);
+ msp->head = (msize|INUSE_BITS);
+ m->seg.base = m->least_addr = tbase;
+ m->seg.size = m->footprint = m->max_footprint = tsize;
+ m->magic = mparams.magic;
+ m->release_checks = MAX_RELEASE_CHECK_RATE;
+ m->mflags = mparams.default_mflags;
+ m->extp = 0;
+ m->exts = 0;
+ disable_contiguous(m);
+ init_bins(m);
+ mn = next_chunk(mem2chunk(m));
+ init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) - TOP_FOOT_SIZE);
+ check_top_chunk(m, m->top);
+ return m;
+}
+
+mspace create_mspace(size_t capacity, int locked) {
+ mstate m = 0;
+ size_t msize;
+ ensure_initialization();
+ msize = pad_request(sizeof(struct malloc_state));
+ if (capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {
+ size_t rs = ((capacity == 0)? mparams.granularity :
+ (capacity + TOP_FOOT_SIZE + msize));
+ size_t tsize = granularity_align(rs);
+ char* tbase = (char*)(CALL_MMAP(tsize));
+ if (tbase != CMFAIL) {
+ m = init_user_mstate(tbase, tsize);
+ m->seg.sflags = USE_MMAP_BIT;
+ set_lock(m, locked);
+ }
+ }
+ return (mspace)m;
+}
+
+mspace create_mspace_with_base(void* base, size_t capacity, int locked) {
+ mstate m = 0;
+ size_t msize;
+ ensure_initialization();
+ msize = pad_request(sizeof(struct malloc_state));
+ if (capacity > msize + TOP_FOOT_SIZE &&
+ capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {
+ m = init_user_mstate((char*)base, capacity);
+ m->seg.sflags = EXTERN_BIT;
+ set_lock(m, locked);
+ }
+ return (mspace)m;
+}
+
+int mspace_track_large_chunks(mspace msp, int enable) {
+ int ret = 0;
+ mstate ms = (mstate)msp;
+ if (!PREACTION(ms)) {
+ if (!use_mmap(ms))
+ ret = 1;
+ if (!enable)
+ enable_mmap(ms);
+ else
+ disable_mmap(ms);
+ POSTACTION(ms);
+ }
+ return ret;
+}
+
+size_t destroy_mspace(mspace msp) {
+ size_t freed = 0;
+ mstate ms = (mstate)msp;
+ if (ok_magic(ms)) {
+ msegmentptr sp = &ms->seg;
+ (void)DESTROY_LOCK(&ms->mutex); /* destroy before unmapped */
+ while (sp != 0) {
+ char* base = sp->base;
+ size_t size = sp->size;
+ flag_t flag = sp->sflags;
+ sp = sp->next;
+ if ((flag & USE_MMAP_BIT) && !(flag & EXTERN_BIT) &&
+ CALL_MUNMAP(base, size) == 0)
+ freed += size;
+ }
+ }
+ else {
+ USAGE_ERROR_ACTION(ms,ms);
+ }
+ return freed;
+}
+
+/*
+ mspace versions of routines are near-clones of the global
+ versions. This is not so nice but better than the alternatives.
+*/
+
+void* mspace_malloc(mspace msp, size_t bytes) {
+ mstate ms = (mstate)msp;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms,ms);
+ return 0;
+ }
+ if (!PREACTION(ms)) {
+ void* mem;
+ size_t nb;
+ if (bytes <= MAX_SMALL_REQUEST) {
+ bindex_t idx;
+ binmap_t smallbits;
+ nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : pad_request(bytes);
+ idx = small_index(nb);
+ smallbits = ms->smallmap >> idx;
+
+ if ((smallbits & 0x3U) != 0) { /* Remainderless fit to a smallbin. */
+ mchunkptr b, p;
+ idx += ~smallbits & 1; /* Uses next bin if idx empty */
+ b = smallbin_at(ms, idx);
+ p = b->fd;
+ assert(chunksize(p) == small_index2size(idx));
+ unlink_first_small_chunk(ms, b, p, idx);
+ set_inuse_and_pinuse(ms, p, small_index2size(idx));
+ mem = chunk2mem(p);
+ check_malloced_chunk(ms, mem, nb);
+ goto postaction;
+ }
+
+ else if (nb > ms->dvsize) {
+ if (smallbits != 0) { /* Use chunk in next nonempty smallbin */
+ mchunkptr b, p, r;
+ size_t rsize;
+ bindex_t i;
+ binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx));
+ binmap_t leastbit = least_bit(leftbits);
+ compute_bit2idx(leastbit, i);
+ b = smallbin_at(ms, i);
+ p = b->fd;
+ assert(chunksize(p) == small_index2size(i));
+ unlink_first_small_chunk(ms, b, p, i);
+ rsize = small_index2size(i) - nb;
+ /* Fit here cannot be remainderless if 4byte sizes */
+ if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
+ set_inuse_and_pinuse(ms, p, small_index2size(i));
+ else {
+ set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
+ r = chunk_plus_offset(p, nb);
+ set_size_and_pinuse_of_free_chunk(r, rsize);
+ replace_dv(ms, r, rsize);
+ }
+ mem = chunk2mem(p);
+ check_malloced_chunk(ms, mem, nb);
+ goto postaction;
+ }
+
+ else if (ms->treemap != 0 && (mem = tmalloc_small(ms, nb)) != 0) {
+ check_malloced_chunk(ms, mem, nb);
+ goto postaction;
+ }
+ }
+ }
+ else if (bytes >= MAX_REQUEST)
+ nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
+ else {
+ nb = pad_request(bytes);
+ if (ms->treemap != 0 && (mem = tmalloc_large(ms, nb)) != 0) {
+ check_malloced_chunk(ms, mem, nb);
+ goto postaction;
+ }
+ }
+
+ if (nb <= ms->dvsize) {
+ size_t rsize = ms->dvsize - nb;
+ mchunkptr p = ms->dv;
+ if (rsize >= MIN_CHUNK_SIZE) { /* split dv */
+ mchunkptr r = ms->dv = chunk_plus_offset(p, nb);
+ ms->dvsize = rsize;
+ set_size_and_pinuse_of_free_chunk(r, rsize);
+ set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
+ }
+ else { /* exhaust dv */
+ size_t dvs = ms->dvsize;
+ ms->dvsize = 0;
+ ms->dv = 0;
+ set_inuse_and_pinuse(ms, p, dvs);
+ }
+ mem = chunk2mem(p);
+ check_malloced_chunk(ms, mem, nb);
+ goto postaction;
+ }
+
+ else if (nb < ms->topsize) { /* Split top */
+ size_t rsize = ms->topsize -= nb;
+ mchunkptr p = ms->top;
+ mchunkptr r = ms->top = chunk_plus_offset(p, nb);
+ r->head = rsize | PINUSE_BIT;
+ set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
+ mem = chunk2mem(p);
+ check_top_chunk(ms, ms->top);
+ check_malloced_chunk(ms, mem, nb);
+ goto postaction;
+ }
+
+ mem = sys_alloc(ms, nb);
+
+ postaction:
+ POSTACTION(ms);
+ return mem;
+ }
+
+ return 0;
+}
+
+void mspace_free(mspace msp, void* mem) {
+ if (mem != 0) {
+ mchunkptr p = mem2chunk(mem);
+#if FOOTERS
+ mstate fm = get_mstate_for(p);
+ (void)msp; /* placate people compiling -Wunused */
+#else /* FOOTERS */
+ mstate fm = (mstate)msp;
+#endif /* FOOTERS */
+ if (!ok_magic(fm)) {
+ USAGE_ERROR_ACTION(fm, p);
+ return;
+ }
+ if (!PREACTION(fm)) {
+ check_inuse_chunk(fm, p);
+ if (RTCHECK(ok_address(fm, p) && ok_inuse(p))) {
+ size_t psize = chunksize(p);
+ mchunkptr next = chunk_plus_offset(p, psize);
+ if (!pinuse(p)) {
+ size_t prevsize = p->prev_foot;
+ if (is_mmapped(p)) {
+ psize += prevsize + MMAP_FOOT_PAD;
+ if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
+ fm->footprint -= psize;
+ goto postaction;
+ }
+ else {
+ mchunkptr prev = chunk_minus_offset(p, prevsize);
+ psize += prevsize;
+ p = prev;
+ if (RTCHECK(ok_address(fm, prev))) { /* consolidate backward */
+ if (p != fm->dv) {
+ unlink_chunk(fm, p, prevsize);
+ }
+ else if ((next->head & INUSE_BITS) == INUSE_BITS) {
+ fm->dvsize = psize;
+ set_free_with_pinuse(p, psize, next);
+ goto postaction;
+ }
+ }
+ else
+ goto erroraction;
+ }
+ }
+
+ if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) {
+ if (!cinuse(next)) { /* consolidate forward */
+ if (next == fm->top) {
+ size_t tsize = fm->topsize += psize;
+ fm->top = p;
+ p->head = tsize | PINUSE_BIT;
+ if (p == fm->dv) {
+ fm->dv = 0;
+ fm->dvsize = 0;
+ }
+ if (should_trim(fm, tsize))
+ sys_trim(fm, 0);
+ goto postaction;
+ }
+ else if (next == fm->dv) {
+ size_t dsize = fm->dvsize += psize;
+ fm->dv = p;
+ set_size_and_pinuse_of_free_chunk(p, dsize);
+ goto postaction;
+ }
+ else {
+ size_t nsize = chunksize(next);
+ psize += nsize;
+ unlink_chunk(fm, next, nsize);
+ set_size_and_pinuse_of_free_chunk(p, psize);
+ if (p == fm->dv) {
+ fm->dvsize = psize;
+ goto postaction;
+ }
+ }
+ }
+ else
+ set_free_with_pinuse(p, psize, next);
+
+ if (is_small(psize)) {
+ insert_small_chunk(fm, p, psize);
+ check_free_chunk(fm, p);
+ }
+ else {
+ tchunkptr tp = (tchunkptr)p;
+ insert_large_chunk(fm, tp, psize);
+ check_free_chunk(fm, p);
+ if (--fm->release_checks == 0)
+ release_unused_segments(fm);
+ }
+ goto postaction;
+ }
+ }
+ erroraction:
+ USAGE_ERROR_ACTION(fm, p);
+ postaction:
+ POSTACTION(fm);
+ }
+ }
+}
+
+void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size) {
+ void* mem;
+ size_t req = 0;
+ mstate ms = (mstate)msp;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms,ms);
+ return 0;
+ }
+ if (n_elements != 0) {
+ req = n_elements * elem_size;
+ if (((n_elements | elem_size) & ~(size_t)0xffff) &&
+ (req / n_elements != elem_size))
+ req = MAX_SIZE_T; /* force downstream failure on overflow */
+ }
+ mem = internal_malloc(ms, req);
+ if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
+ memset(mem, 0, req);
+ return mem;
+}
+
+void* mspace_realloc(mspace msp, void* oldmem, size_t bytes) {
+ void* mem = 0;
+ if (oldmem == 0) {
+ mem = mspace_malloc(msp, bytes);
+ }
+ else if (bytes >= MAX_REQUEST) {
+ MALLOC_FAILURE_ACTION;
+ }
+#ifdef REALLOC_ZERO_BYTES_FREES
+ else if (bytes == 0) {
+ mspace_free(msp, oldmem);
+ }
+#endif /* REALLOC_ZERO_BYTES_FREES */
+ else {
+ size_t nb = request2size(bytes);
+ mchunkptr oldp = mem2chunk(oldmem);
+#if ! FOOTERS
+ mstate m = (mstate)msp;
+#else /* FOOTERS */
+ mstate m = get_mstate_for(oldp);
+ if (!ok_magic(m)) {
+ USAGE_ERROR_ACTION(m, oldmem);
+ return 0;
+ }
+#endif /* FOOTERS */
+ if (!PREACTION(m)) {
+ mchunkptr newp = try_realloc_chunk(m, oldp, nb, 1);
+ POSTACTION(m);
+ if (newp != 0) {
+ check_inuse_chunk(m, newp);
+ mem = chunk2mem(newp);
+ }
+ else {
+ mem = mspace_malloc(m, bytes);
+ if (mem != 0) {
+ size_t oc = chunksize(oldp) - overhead_for(oldp);
+ memcpy(mem, oldmem, (oc < bytes)? oc : bytes);
+ mspace_free(m, oldmem);
+ }
+ }
+ }
+ }
+ return mem;
+}
+
+void* mspace_realloc_in_place(mspace msp, void* oldmem, size_t bytes) {
+ void* mem = 0;
+ if (oldmem != 0) {
+ if (bytes >= MAX_REQUEST) {
+ MALLOC_FAILURE_ACTION;
+ }
+ else {
+ size_t nb = request2size(bytes);
+ mchunkptr oldp = mem2chunk(oldmem);
+#if ! FOOTERS
+ mstate m = (mstate)msp;
+#else /* FOOTERS */
+ mstate m = get_mstate_for(oldp);
+ (void)msp; /* placate people compiling -Wunused */
+ if (!ok_magic(m)) {
+ USAGE_ERROR_ACTION(m, oldmem);
+ return 0;
+ }
+#endif /* FOOTERS */
+ if (!PREACTION(m)) {
+ mchunkptr newp = try_realloc_chunk(m, oldp, nb, 0);
+ POSTACTION(m);
+ if (newp == oldp) {
+ check_inuse_chunk(m, newp);
+ mem = oldmem;
+ }
+ }
+ }
+ }
+ return mem;
+}
+
+void* mspace_memalign(mspace msp, size_t alignment, size_t bytes) {
+ mstate ms = (mstate)msp;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms,ms);
+ return 0;
+ }
+ if (alignment <= MALLOC_ALIGNMENT)
+ return mspace_malloc(msp, bytes);
+ return internal_memalign(ms, alignment, bytes);
+}
+
+void** mspace_independent_calloc(mspace msp, size_t n_elements,
+ size_t elem_size, void* chunks[]) {
+ size_t sz = elem_size; /* serves as 1-element array */
+ mstate ms = (mstate)msp;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms,ms);
+ return 0;
+ }
+ return ialloc(ms, n_elements, &sz, 3, chunks);
+}
+
+void** mspace_independent_comalloc(mspace msp, size_t n_elements,
+ size_t sizes[], void* chunks[]) {
+ mstate ms = (mstate)msp;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms,ms);
+ return 0;
+ }
+ return ialloc(ms, n_elements, sizes, 0, chunks);
+}
+
+size_t mspace_bulk_free(mspace msp, void* array[], size_t nelem) {
+ return internal_bulk_free((mstate)msp, array, nelem);
+}
+
+#if MALLOC_INSPECT_ALL
+void mspace_inspect_all(mspace msp,
+ void(*handler)(void *start,
+ void *end,
+ size_t used_bytes,
+ void* callback_arg),
+ void* arg) {
+ mstate ms = (mstate)msp;
+ if (ok_magic(ms)) {
+ if (!PREACTION(ms)) {
+ internal_inspect_all(ms, handler, arg);
+ POSTACTION(ms);
+ }
+ }
+ else {
+ USAGE_ERROR_ACTION(ms,ms);
+ }
+}
+#endif /* MALLOC_INSPECT_ALL */
+
+int mspace_trim(mspace msp, size_t pad) {
+ int result = 0;
+ mstate ms = (mstate)msp;
+ if (ok_magic(ms)) {
+ if (!PREACTION(ms)) {
+ result = sys_trim(ms, pad);
+ POSTACTION(ms);
+ }
+ }
+ else {
+ USAGE_ERROR_ACTION(ms,ms);
+ }
+ return result;
+}
+
+#if !NO_MALLOC_STATS
+void mspace_malloc_stats(mspace msp) {
+ mstate ms = (mstate)msp;
+ if (ok_magic(ms)) {
+ internal_malloc_stats(ms);
+ }
+ else {
+ USAGE_ERROR_ACTION(ms,ms);
+ }
+}
+#endif /* NO_MALLOC_STATS */
+
+size_t mspace_footprint(mspace msp) {
+ size_t result = 0;
+ mstate ms = (mstate)msp;
+ if (ok_magic(ms)) {
+ result = ms->footprint;
+ }
+ else {
+ USAGE_ERROR_ACTION(ms,ms);
+ }
+ return result;
+}
+
+size_t mspace_max_footprint(mspace msp) {
+ size_t result = 0;
+ mstate ms = (mstate)msp;
+ if (ok_magic(ms)) {
+ result = ms->max_footprint;
+ }
+ else {
+ USAGE_ERROR_ACTION(ms,ms);
+ }
+ return result;
+}
+
+size_t mspace_footprint_limit(mspace msp) {
+ size_t result = 0;
+ mstate ms = (mstate)msp;
+ if (ok_magic(ms)) {
+ size_t maf = ms->footprint_limit;
+ result = (maf == 0) ? MAX_SIZE_T : maf;
+ }
+ else {
+ USAGE_ERROR_ACTION(ms,ms);
+ }
+ return result;
+}
+
+size_t mspace_set_footprint_limit(mspace msp, size_t bytes) {
+ size_t result = 0;
+ mstate ms = (mstate)msp;
+ if (ok_magic(ms)) {
+ if (bytes == 0)
+ result = granularity_align(1); /* Use minimal size */
+ if (bytes == MAX_SIZE_T)
+ result = 0; /* disable */
+ else
+ result = granularity_align(bytes);
+ ms->footprint_limit = result;
+ }
+ else {
+ USAGE_ERROR_ACTION(ms,ms);
+ }
+ return result;
+}
+
+#if !NO_MALLINFO
+struct mallinfo mspace_mallinfo(mspace msp) {
+ mstate ms = (mstate)msp;
+ if (!ok_magic(ms)) {
+ USAGE_ERROR_ACTION(ms,ms);
+ }
+ return internal_mallinfo(ms);
+}
+#endif /* NO_MALLINFO */
+
+size_t mspace_usable_size(void* mem) {
+ if (mem != 0) {
+ mchunkptr p = mem2chunk(mem);
+ if (is_inuse(p))
+ return chunksize(p) - overhead_for(p);
+ }
+ return 0;
+}
+
+int mspace_mallopt(int param_number, int value) {
+ return change_mparam(param_number, value);
+}
+
+#endif /* MSPACES */
+
+
+/* -------------------- Alternative MORECORE functions ------------------- */
+
+/*
+ Guidelines for creating a custom version of MORECORE:
+
+ * For best performance, MORECORE should allocate in multiples of pagesize.
+ * MORECORE may allocate more memory than requested. (Or even less,
+ but this will usually result in a malloc failure.)
+ * MORECORE must not allocate memory when given argument zero, but
+ instead return one past the end address of memory from previous
+ nonzero call.
+ * For best performance, consecutive calls to MORECORE with positive
+ arguments should return increasing addresses, indicating that
+ space has been contiguously extended.
+ * Even though consecutive calls to MORECORE need not return contiguous
+ addresses, it must be OK for malloc'ed chunks to span multiple
+ regions in those cases where they do happen to be contiguous.
+ * MORECORE need not handle negative arguments -- it may instead
+ just return MFAIL when given negative arguments.
+ Negative arguments are always multiples of pagesize. MORECORE
+ must not misinterpret negative args as large positive unsigned
+ args. You can suppress all such calls from even occurring by defining
+ MORECORE_CANNOT_TRIM,
+
+ As an example alternative MORECORE, here is a custom allocator
+ kindly contributed for pre-OSX macOS. It uses virtually but not
+ necessarily physically contiguous non-paged memory (locked in,
+ present and won't get swapped out). You can use it by uncommenting
+ this section, adding some #includes, and setting up the appropriate
+ defines above:
+
+ #define MORECORE osMoreCore
+
+ There is also a shutdown routine that should somehow be called for
+ cleanup upon program exit.
+
+ #define MAX_POOL_ENTRIES 100
+ #define MINIMUM_MORECORE_SIZE (64 * 1024U)
+ static int next_os_pool;
+ void *our_os_pools[MAX_POOL_ENTRIES];
+
+ void *osMoreCore(int size)
+ {
+ void *ptr = 0;
+ static void *sbrk_top = 0;
+
+ if (size > 0)
+ {
+ if (size < MINIMUM_MORECORE_SIZE)
+ size = MINIMUM_MORECORE_SIZE;
+ if (CurrentExecutionLevel() == kTaskLevel)
+ ptr = PoolAllocateResident(size + RM_PAGE_SIZE, 0);
+ if (ptr == 0)
+ {
+ return (void *) MFAIL;
+ }
+ // save ptrs so they can be freed during cleanup
+ our_os_pools[next_os_pool] = ptr;
+ next_os_pool++;
+ ptr = (void *) ((((size_t) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK);
+ sbrk_top = (char *) ptr + size;
+ return ptr;
+ }
+ else if (size < 0)
+ {
+ // we don't currently support shrink behavior
+ return (void *) MFAIL;
+ }
+ else
+ {
+ return sbrk_top;
+ }
+ }
+
+ // cleanup any allocated memory pools
+ // called as last thing before shutting down driver
+
+ void osCleanupMem(void)
+ {
+ void **ptr;
+
+ for (ptr = our_os_pools; ptr < &our_os_pools[MAX_POOL_ENTRIES]; ptr++)
+ if (*ptr)
+ {
+ PoolDeallocate(*ptr);
+ *ptr = 0;
+ }
+ }
+
+*/
+
+
+/* -----------------------------------------------------------------------
+History:
+ v2.8.5 Sun May 22 10:26:02 2011 Doug Lea (dl at gee)
+ * Always perform unlink checks unless INSECURE
+ * Add posix_memalign.
+ * Improve realloc to expand in more cases; expose realloc_in_place.
+ Thanks to Peter Buhr for the suggestion.
+ * Add footprint_limit, inspect_all, bulk_free. Thanks
+ to Barry Hayes and others for the suggestions.
+ * Internal refactorings to avoid calls while holding locks
+ * Use non-reentrant locks by default. Thanks to Roland McGrath
+ for the suggestion.
+ * Small fixes to mspace_destroy, reset_on_error.
+ * Various configuration extensions/changes. Thanks
+ to all who contributed these.
+
+ V2.8.4a Thu Apr 28 14:39:43 2011 (dl at gee.cs.oswego.edu)
+ * Update Creative Commons URL
+
+ V2.8.4 Wed May 27 09:56:23 2009 Doug Lea (dl at gee)
+ * Use zeros instead of prev foot for is_mmapped
+ * Add mspace_track_large_chunks; thanks to Jean Brouwers
+ * Fix set_inuse in internal_realloc; thanks to Jean Brouwers
+ * Fix insufficient sys_alloc padding when using 16byte alignment
+ * Fix bad error check in mspace_footprint
+ * Adaptations for ptmalloc; thanks to Wolfram Gloger.
+ * Reentrant spin locks; thanks to Earl Chew and others
+ * Win32 improvements; thanks to Niall Douglas and Earl Chew
+ * Add NO_SEGMENT_TRAVERSAL and MAX_RELEASE_CHECK_RATE options
+ * Extension hook in malloc_state
+ * Various small adjustments to reduce warnings on some compilers
+ * Various configuration extensions/changes for more platforms. Thanks
+ to all who contributed these.
+
+ V2.8.3 Thu Sep 22 11:16:32 2005 Doug Lea (dl at gee)
+ * Add max_footprint functions
+ * Ensure all appropriate literals are size_t
+ * Fix conditional compilation problem for some #define settings
+ * Avoid concatenating segments with the one provided
+ in create_mspace_with_base
+ * Rename some variables to avoid compiler shadowing warnings
+ * Use explicit lock initialization.
+ * Better handling of sbrk interference.
+ * Simplify and fix segment insertion, trimming and mspace_destroy
+ * Reinstate REALLOC_ZERO_BYTES_FREES option from 2.7.x
+ * Thanks especially to Dennis Flanagan for help on these.
+
+ V2.8.2 Sun Jun 12 16:01:10 2005 Doug Lea (dl at gee)
+ * Fix memalign brace error.
+
+ V2.8.1 Wed Jun 8 16:11:46 2005 Doug Lea (dl at gee)
+ * Fix improper #endif nesting in C++
+ * Add explicit casts needed for C++
+
+ V2.8.0 Mon May 30 14:09:02 2005 Doug Lea (dl at gee)
+ * Use trees for large bins
+ * Support mspaces
+ * Use segments to unify sbrk-based and mmap-based system allocation,
+ removing need for emulation on most platforms without sbrk.
+ * Default safety checks
+ * Optional footer checks. Thanks to William Robertson for the idea.
+ * Internal code refactoring
+ * Incorporate suggestions and platform-specific changes.
+ Thanks to Dennis Flanagan, Colin Plumb, Niall Douglas,
+ Aaron Bachmann, Emery Berger, and others.
+ * Speed up non-fastbin processing enough to remove fastbins.
+ * Remove useless cfree() to avoid conflicts with other apps.
+ * Remove internal memcpy, memset. Compilers handle builtins better.
+ * Remove some options that no one ever used and rename others.
+
+ V2.7.2 Sat Aug 17 09:07:30 2002 Doug Lea (dl at gee)
+ * Fix malloc_state bitmap array misdeclaration
+
+ V2.7.1 Thu Jul 25 10:58:03 2002 Doug Lea (dl at gee)
+ * Allow tuning of FIRST_SORTED_BIN_SIZE
+ * Use PTR_UINT as type for all ptr->int casts. Thanks to John Belmonte.
+ * Better detection and support for non-contiguousness of MORECORE.
+ Thanks to Andreas Mueller, Conal Walsh, and Wolfram Gloger
+ * Bypass most of malloc if no frees. Thanks To Emery Berger.
+ * Fix freeing of old top non-contiguous chunk im sysmalloc.
+ * Raised default trim and map thresholds to 256K.
+ * Fix mmap-related #defines. Thanks to Lubos Lunak.
+ * Fix copy macros; added LACKS_FCNTL_H. Thanks to Neal Walfield.
+ * Branch-free bin calculation
+ * Default trim and mmap thresholds now 256K.
+
+ V2.7.0 Sun Mar 11 14:14:06 2001 Doug Lea (dl at gee)
+ * Introduce independent_comalloc and independent_calloc.
+ Thanks to Michael Pachos for motivation and help.
+ * Make optional .h file available
+ * Allow > 2GB requests on 32bit systems.
+ * new WIN32 sbrk, mmap, munmap, lock code from <Walter@GeNeSys-e.de>.
+ Thanks also to Andreas Mueller <a.mueller at paradatec.de>,
+ and Anonymous.
+ * Allow override of MALLOC_ALIGNMENT (Thanks to Ruud Waij for
+ helping test this.)
+ * memalign: check alignment arg
+ * realloc: don't try to shift chunks backwards, since this
+ leads to more fragmentation in some programs and doesn't
+ seem to help in any others.
+ * Collect all cases in malloc requiring system memory into sysmalloc
+ * Use mmap as backup to sbrk
+ * Place all internal state in malloc_state
+ * Introduce fastbins (although similar to 2.5.1)
+ * Many minor tunings and cosmetic improvements
+ * Introduce USE_PUBLIC_MALLOC_WRAPPERS, USE_MALLOC_LOCK
+ * Introduce MALLOC_FAILURE_ACTION, MORECORE_CONTIGUOUS
+ Thanks to Tony E. Bennett <tbennett@nvidia.com> and others.
+ * Include errno.h to support default failure action.
+
+ V2.6.6 Sun Dec 5 07:42:19 1999 Doug Lea (dl at gee)
+ * return null for negative arguments
+ * Added Several WIN32 cleanups from Martin C. Fong <mcfong at yahoo.com>
+ * Add 'LACKS_SYS_PARAM_H' for those systems without 'sys/param.h'
+ (e.g. WIN32 platforms)
+ * Cleanup header file inclusion for WIN32 platforms
+ * Cleanup code to avoid Microsoft Visual C++ compiler complaints
+ * Add 'USE_DL_PREFIX' to quickly allow co-existence with existing
+ memory allocation routines
+ * Set 'malloc_getpagesize' for WIN32 platforms (needs more work)
+ * Use 'assert' rather than 'ASSERT' in WIN32 code to conform to
+ usage of 'assert' in non-WIN32 code
+ * Improve WIN32 'sbrk()' emulation's 'findRegion()' routine to
+ avoid infinite loop
+ * Always call 'fREe()' rather than 'free()'
+
+ V2.6.5 Wed Jun 17 15:57:31 1998 Doug Lea (dl at gee)
+ * Fixed ordering problem with boundary-stamping
+
+ V2.6.3 Sun May 19 08:17:58 1996 Doug Lea (dl at gee)
+ * Added pvalloc, as recommended by H.J. Liu
+ * Added 64bit pointer support mainly from Wolfram Gloger
+ * Added anonymously donated WIN32 sbrk emulation
+ * Malloc, calloc, getpagesize: add optimizations from Raymond Nijssen
+ * malloc_extend_top: fix mask error that caused wastage after
+ foreign sbrks
+ * Add linux mremap support code from HJ Liu
+
+ V2.6.2 Tue Dec 5 06:52:55 1995 Doug Lea (dl at gee)
+ * Integrated most documentation with the code.
+ * Add support for mmap, with help from
+ Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
+ * Use last_remainder in more cases.
+ * Pack bins using idea from colin@nyx10.cs.du.edu
+ * Use ordered bins instead of best-fit threshhold
+ * Eliminate block-local decls to simplify tracing and debugging.
+ * Support another case of realloc via move into top
+ * Fix error occuring when initial sbrk_base not word-aligned.
+ * Rely on page size for units instead of SBRK_UNIT to
+ avoid surprises about sbrk alignment conventions.
+ * Add mallinfo, mallopt. Thanks to Raymond Nijssen
+ (raymond@es.ele.tue.nl) for the suggestion.
+ * Add `pad' argument to malloc_trim and top_pad mallopt parameter.
+ * More precautions for cases where other routines call sbrk,
+ courtesy of Wolfram Gloger (Gloger@lrz.uni-muenchen.de).
+ * Added macros etc., allowing use in linux libc from
+ H.J. Lu (hjl@gnu.ai.mit.edu)
+ * Inverted this history list
+
+ V2.6.1 Sat Dec 2 14:10:57 1995 Doug Lea (dl at gee)
+ * Re-tuned and fixed to behave more nicely with V2.6.0 changes.
+ * Removed all preallocation code since under current scheme
+ the work required to undo bad preallocations exceeds
+ the work saved in good cases for most test programs.
+ * No longer use return list or unconsolidated bins since
+ no scheme using them consistently outperforms those that don't
+ given above changes.
+ * Use best fit for very large chunks to prevent some worst-cases.
+ * Added some support for debugging
+
+ V2.6.0 Sat Nov 4 07:05:23 1995 Doug Lea (dl at gee)
+ * Removed footers when chunks are in use. Thanks to
+ Paul Wilson (wilson@cs.texas.edu) for the suggestion.
+
+ V2.5.4 Wed Nov 1 07:54:51 1995 Doug Lea (dl at gee)
+ * Added malloc_trim, with help from Wolfram Gloger
+ (wmglo@Dent.MED.Uni-Muenchen.DE).
+
+ V2.5.3 Tue Apr 26 10:16:01 1994 Doug Lea (dl at g)
+
+ V2.5.2 Tue Apr 5 16:20:40 1994 Doug Lea (dl at g)
+ * realloc: try to expand in both directions
+ * malloc: swap order of clean-bin strategy;
+ * realloc: only conditionally expand backwards
+ * Try not to scavenge used bins
+ * Use bin counts as a guide to preallocation
+ * Occasionally bin return list chunks in first scan
+ * Add a few optimizations from colin@nyx10.cs.du.edu
+
+ V2.5.1 Sat Aug 14 15:40:43 1993 Doug Lea (dl at g)
+ * faster bin computation & slightly different binning
+ * merged all consolidations to one part of malloc proper
+ (eliminating old malloc_find_space & malloc_clean_bin)
+ * Scan 2 returns chunks (not just 1)
+ * Propagate failure in realloc if malloc returns 0
+ * Add stuff to allow compilation on non-ANSI compilers
+ from kpv@research.att.com
+
+ V2.5 Sat Aug 7 07:41:59 1993 Doug Lea (dl at g.oswego.edu)
+ * removed potential for odd address access in prev_chunk
+ * removed dependency on getpagesize.h
+ * misc cosmetics and a bit more internal documentation
+ * anticosmetics: mangled names in macros to evade debugger strangeness
+ * tested on sparc, hp-700, dec-mips, rs6000
+ with gcc & native cc (hp, dec only) allowing
+ Detlefs & Zorn comparison study (in SIGPLAN Notices.)
+
+ Trial version Fri Aug 28 13:14:29 1992 Doug Lea (dl at g.oswego.edu)
+ * Based loosely on libg++-1.2X malloc. (It retains some of the overall
+ structure of old version, but most details differ.)
+
+*/
+
--- /dev/null
+#include <stdio.h>
+#include <algorithm>
+#include <new>
+#include <stdarg.h>
+
+#include "model.h"
+#include "action.h"
+#include "nodestack.h"
+#include "schedule.h"
+#include "snapshot-interface.h"
+#include "common.h"
+#include "datarace.h"
+#include "threads-model.h"
+#include "output.h"
+#include "traceanalysis.h"
+#include "execution.h"
+#include "bugmessage.h"
+
+ModelChecker *model;
+
+/** @brief Constructor */
+ModelChecker::ModelChecker(struct model_params params) :
+ /* Initialize default scheduler */
+ params(params),
+ scheduler(new Scheduler()),
+ node_stack(new NodeStack()),
+ execution(new ModelExecution(this, &this->params, scheduler, node_stack)),
+ execution_number(1),
+ diverge(NULL),
+ earliest_diverge(NULL),
+ trace_analyses()
+{
+}
+
+/** @brief Destructor */
+ModelChecker::~ModelChecker()
+{
+ delete node_stack;
+ delete scheduler;
+}
+
+/**
+ * Restores user program to initial state and resets all model-checker data
+ * structures.
+ */
+void ModelChecker::reset_to_initial_state()
+{
+ DEBUG("+++ Resetting to initial state +++\n");
+ node_stack->reset_execution();
+
+ /**
+ * FIXME: if we utilize partial rollback, we will need to free only
+ * those pending actions which were NOT pending before the rollback
+ * point
+ */
+ for (unsigned int i = 0; i < get_num_threads(); i++)
+ delete get_thread(int_to_id(i))->get_pending();
+
+ snapshot_backtrack_before(0);
+}
+
+/** @return the number of user threads created during this execution */
+unsigned int ModelChecker::get_num_threads() const
+{
+ return execution->get_num_threads();
+}
+
+/**
+ * Must be called from user-thread context (e.g., through the global
+ * thread_current() interface)
+ *
+ * @return The currently executing Thread.
+ */
+Thread * ModelChecker::get_current_thread() const
+{
+ return scheduler->get_current_thread();
+}
+
+/**
+ * @brief Choose the next thread to execute.
+ *
+ * This function chooses the next thread that should execute. It can enforce
+ * execution replay/backtracking or, if the model-checker has no preference
+ * regarding the next thread (i.e., when exploring a new execution ordering),
+ * we defer to the scheduler.
+ *
+ * @return The next chosen thread to run, if any exist. Or else if the current
+ * execution should terminate, return NULL.
+ */
+Thread * ModelChecker::get_next_thread()
+{
+ thread_id_t tid;
+
+ /*
+ * Have we completed exploring the preselected path? Then let the
+ * scheduler decide
+ */
+ if (diverge == NULL)
+ return scheduler->select_next_thread(node_stack->get_head());
+
+
+ /* Else, we are trying to replay an execution */
+ ModelAction *next = node_stack->get_next()->get_action();
+
+ if (next == diverge) {
+ if (earliest_diverge == NULL || *diverge < *earliest_diverge)
+ earliest_diverge = diverge;
+
+ Node *nextnode = next->get_node();
+ Node *prevnode = nextnode->get_parent();
+ scheduler->update_sleep_set(prevnode);
+
+ /* Reached divergence point */
+ if (nextnode->increment_behaviors()) {
+ /* Execute the same thread with a new behavior */
+ tid = next->get_tid();
+ node_stack->pop_restofstack(2);
+ } else {
+ ASSERT(prevnode);
+ /* Make a different thread execute for next step */
+ scheduler->add_sleep(get_thread(next->get_tid()));
+ tid = prevnode->get_next_backtrack();
+ /* Make sure the backtracked thread isn't sleeping. */
+ node_stack->pop_restofstack(1);
+ if (diverge == earliest_diverge) {
+ earliest_diverge = prevnode->get_action();
+ }
+ }
+ /* Start the round robin scheduler from this thread id */
+ scheduler->set_scheduler_thread(tid);
+ /* The correct sleep set is in the parent node. */
+ execute_sleep_set();
+
+ DEBUG("*** Divergence point ***\n");
+
+ diverge = NULL;
+ } else {
+ tid = next->get_tid();
+ }
+ DEBUG("*** ModelChecker chose next thread = %d ***\n", id_to_int(tid));
+ ASSERT(tid != THREAD_ID_T_NONE);
+ return get_thread(id_to_int(tid));
+}
+
+/**
+ * We need to know what the next actions of all threads in the sleep
+ * set will be. This method computes them and stores the actions at
+ * the corresponding thread object's pending action.
+ */
+void ModelChecker::execute_sleep_set()
+{
+ for (unsigned int i = 0; i < get_num_threads(); i++) {
+ thread_id_t tid = int_to_id(i);
+ Thread *thr = get_thread(tid);
+ if (scheduler->is_sleep_set(thr) && thr->get_pending()) {
+ thr->get_pending()->set_sleep_flag();
+ }
+ }
+}
+
+/**
+ * @brief Assert a bug in the executing program.
+ *
+ * Use this function to assert any sort of bug in the user program. If the
+ * current trace is feasible (actually, a prefix of some feasible execution),
+ * then this execution will be aborted, printing the appropriate message. If
+ * the current trace is not yet feasible, the error message will be stashed and
+ * printed if the execution ever becomes feasible.
+ *
+ * @param msg Descriptive message for the bug (do not include newline char)
+ * @return True if bug is immediately-feasible
+ */
+bool ModelChecker::assert_bug(const char *msg, ...)
+{
+ char str[800];
+
+ va_list ap;
+ va_start(ap, msg);
+ vsnprintf(str, sizeof(str), msg, ap);
+ va_end(ap);
+
+ return execution->assert_bug(str);
+}
+
+/**
+ * @brief Assert a bug in the executing program, asserted by a user thread
+ * @see ModelChecker::assert_bug
+ * @param msg Descriptive message for the bug (do not include newline char)
+ */
+void ModelChecker::assert_user_bug(const char *msg)
+{
+ /* If feasible bug, bail out now */
+ if (assert_bug(msg))
+ switch_to_master(NULL);
+}
+
+/** @brief Print bug report listing for this execution (if any bugs exist) */
+void ModelChecker::print_bugs() const
+{
+ SnapVector<bug_message *> *bugs = execution->get_bugs();
+
+ model_print("Bug report: %zu bug%s detected\n",
+ bugs->size(),
+ bugs->size() > 1 ? "s" : "");
+ for (unsigned int i = 0; i < bugs->size(); i++)
+ (*bugs)[i]->print();
+}
+
+/**
+ * @brief Record end-of-execution stats
+ *
+ * Must be run when exiting an execution. Records various stats.
+ * @see struct execution_stats
+ */
+void ModelChecker::record_stats()
+{
+ stats.num_total++;
+ if (!execution->isfeasibleprefix())
+ stats.num_infeasible++;
+ else if (execution->have_bug_reports())
+ stats.num_buggy_executions++;
+ else if (execution->is_complete_execution())
+ stats.num_complete++;
+ else {
+ stats.num_redundant++;
+
+ /**
+ * @todo We can violate this ASSERT() when fairness/sleep sets
+ * conflict to cause an execution to terminate, e.g. with:
+ * Scheduler: [0: disabled][1: disabled][2: sleep][3: current, enabled]
+ */
+ //ASSERT(scheduler->all_threads_sleeping());
+ }
+}
+
+/** @brief Print execution stats */
+void ModelChecker::print_stats() const
+{
+ model_print("Number of complete, bug-free executions: %d\n", stats.num_complete);
+ model_print("Number of redundant executions: %d\n", stats.num_redundant);
+ model_print("Number of buggy executions: %d\n", stats.num_buggy_executions);
+ model_print("Number of infeasible executions: %d\n", stats.num_infeasible);
+ model_print("Total executions: %d\n", stats.num_total);
+ if (params.verbose)
+ model_print("Total nodes created: %d\n", node_stack->get_total_nodes());
+}
+
+/**
+ * @brief End-of-exeuction print
+ * @param printbugs Should any existing bugs be printed?
+ */
+void ModelChecker::print_execution(bool printbugs) const
+{
+ model_print("Program output from execution %d:\n",
+ get_execution_number());
+ print_program_output();
+
+ if (params.verbose >= 2) {
+ model_print("\nEarliest divergence point since last feasible execution:\n");
+ if (earliest_diverge)
+ earliest_diverge->print();
+ else
+ model_print("(Not set)\n");
+
+ model_print("\n");
+ print_stats();
+ }
+
+ /* Don't print invalid bugs */
+ if (printbugs && execution->have_bug_reports()) {
+ model_print("\n");
+ print_bugs();
+ }
+
+ model_print("\n");
+ execution->print_summary();
+}
+
+/**
+ * Queries the model-checker for more executions to explore and, if one
+ * exists, resets the model-checker state to execute a new execution.
+ *
+ * @return If there are more executions to explore, return true. Otherwise,
+ * return false.
+ */
+bool ModelChecker::next_execution()
+{
+ DBG();
+ /* Is this execution a feasible execution that's worth bug-checking? */
+ bool complete = execution->isfeasibleprefix() &&
+ (execution->is_complete_execution() ||
+ execution->have_bug_reports());
+
+ /* End-of-execution bug checks */
+ if (complete) {
+ if (execution->is_deadlocked())
+ assert_bug("Deadlock detected");
+
+ checkDataRaces();
+ run_trace_analyses();
+ }
+
+ record_stats();
+
+ /* Output */
+ if (params.verbose || (complete && execution->have_bug_reports()))
+ print_execution(complete);
+ else
+ clear_program_output();
+
+ if (complete)
+ earliest_diverge = NULL;
+
+ if ((diverge = execution->get_next_backtrack()) == NULL)
+ return false;
+
+ if (DBG_ENABLED()) {
+ model_print("Next execution will diverge at:\n");
+ diverge->print();
+ }
+
+ execution_number++;
+
+ reset_to_initial_state();
+ return true;
+}
+
+/** @brief Run trace analyses on complete trace */
+void ModelChecker::run_trace_analyses() {
+ for (unsigned int i = 0; i < trace_analyses.size(); i++)
+ trace_analyses[i]->analyze(execution->get_action_trace());
+}
+
+/**
+ * @brief Get a Thread reference by its ID
+ * @param tid The Thread's ID
+ * @return A Thread reference
+ */
+Thread * ModelChecker::get_thread(thread_id_t tid) const
+{
+ return execution->get_thread(tid);
+}
+
+/**
+ * @brief Get a reference to the Thread in which a ModelAction was executed
+ * @param act The ModelAction
+ * @return A Thread reference
+ */
+Thread * ModelChecker::get_thread(const ModelAction *act) const
+{
+ return execution->get_thread(act);
+}
+
+/**
+ * Switch from a model-checker context to a user-thread context. This is the
+ * complement of ModelChecker::switch_to_master and must be called from the
+ * model-checker context
+ *
+ * @param thread The user-thread to switch to
+ */
+void ModelChecker::switch_from_master(Thread *thread)
+{
+ scheduler->set_current_thread(thread);
+ Thread::swap(&system_context, thread);
+}
+
+/**
+ * Switch from a user-context to the "master thread" context (a.k.a. system
+ * context). This switch is made with the intention of exploring a particular
+ * model-checking action (described by a ModelAction object). Must be called
+ * from a user-thread context.
+ *
+ * @param act The current action that will be explored. May be NULL only if
+ * trace is exiting via an assertion (see ModelExecution::set_assert and
+ * ModelExecution::has_asserted).
+ * @return Return the value returned by the current action
+ */
+uint64_t ModelChecker::switch_to_master(ModelAction *act)
+{
+ DBG();
+ Thread *old = thread_current();
+ scheduler->set_current_thread(NULL);
+ ASSERT(!old->get_pending());
+ old->set_pending(act);
+ if (Thread::swap(old, &system_context) < 0) {
+ perror("swap threads");
+ exit(EXIT_FAILURE);
+ }
+ return old->get_return_value();
+}
+
+/** Wrapper to run the user's main function, with appropriate arguments */
+void user_main_wrapper(void *)
+{
+ user_main(model->params.argc, model->params.argv);
+}
+
+bool ModelChecker::should_terminate_execution()
+{
+ /* Infeasible -> don't take any more steps */
+ if (execution->is_infeasible())
+ return true;
+ else if (execution->isfeasibleprefix() && execution->have_bug_reports()) {
+ execution->set_assert();
+ return true;
+ }
+
+ if (execution->too_many_steps())
+ return true;
+ return false;
+}
+
+/** @brief Run ModelChecker for the user program */
+void ModelChecker::run()
+{
+ do {
+ thrd_t user_thread;
+ Thread *t = new Thread(execution->get_next_id(), &user_thread, &user_main_wrapper, NULL, NULL);
+ execution->add_thread(t);
+
+ do {
+ /*
+ * Stash next pending action(s) for thread(s). There
+ * should only need to stash one thread's action--the
+ * thread which just took a step--plus the first step
+ * for any newly-created thread
+ */
+ for (unsigned int i = 0; i < get_num_threads(); i++) {
+ thread_id_t tid = int_to_id(i);
+ Thread *thr = get_thread(tid);
+ if (!thr->is_model_thread() && !thr->is_complete() && !thr->get_pending()) {
+ switch_from_master(thr);
+ if (thr->is_waiting_on(thr))
+ assert_bug("Deadlock detected (thread %u)", i);
+ }
+ }
+
+ /* Don't schedule threads which should be disabled */
+ for (unsigned int i = 0; i < get_num_threads(); i++) {
+ Thread *th = get_thread(int_to_id(i));
+ ModelAction *act = th->get_pending();
+ if (act && execution->is_enabled(th) && !execution->check_action_enabled(act)) {
+ scheduler->sleep(th);
+ }
+ }
+
+ /* Catch assertions from prior take_step or from
+ * between-ModelAction bugs (e.g., data races) */
+ if (execution->has_asserted())
+ break;
+
+ if (!t)
+ t = get_next_thread();
+ if (!t || t->is_model_thread())
+ break;
+
+ /* Consume the next action for a Thread */
+ ModelAction *curr = t->get_pending();
+ t->set_pending(NULL);
+ t = execution->take_step(curr);
+ } while (!should_terminate_execution());
+
+ } while (next_execution());
+
+ execution->fixup_release_sequences();
+
+ model_print("******* Model-checking complete: *******\n");
+ print_stats();
+
+ /* Have the trace analyses dump their output. */
+ for (unsigned int i = 0; i < trace_analyses.size(); i++)
+ trace_analyses[i]->finish();
+}
--- /dev/null
+/** @file model.h
+ * @brief Core model checker.
+ */
+
+#ifndef __MODEL_H__
+#define __MODEL_H__
+
+#include <cstddef>
+#include <inttypes.h>
+
+#include "mymemory.h"
+#include "hashtable.h"
+#include "config.h"
+#include "modeltypes.h"
+#include "stl-model.h"
+#include "context.h"
+#include "params.h"
+
+/* Forward declaration */
+class Node;
+class NodeStack;
+class CycleGraph;
+class Promise;
+class Scheduler;
+class Thread;
+class ClockVector;
+class TraceAnalysis;
+class ModelExecution;
+class ModelAction;
+
+typedef SnapList<ModelAction *> action_list_t;
+
+/** @brief Model checker execution stats */
+struct execution_stats {
+ int num_total; /**< @brief Total number of executions */
+ int num_infeasible; /**< @brief Number of infeasible executions */
+ int num_buggy_executions; /** @brief Number of buggy executions */
+ int num_complete; /**< @brief Number of feasible, non-buggy, complete executions */
+ int num_redundant; /**< @brief Number of redundant, aborted executions */
+};
+
+/** @brief The central structure for model-checking */
+class ModelChecker {
+public:
+ ModelChecker(struct model_params params);
+ ~ModelChecker();
+
+ void run();
+
+ /** @returns the context for the main model-checking system thread */
+ ucontext_t * get_system_context() { return &system_context; }
+
+ ModelExecution * get_execution() const { return execution; }
+
+ int get_execution_number() const { return execution_number; }
+
+ Thread * get_thread(thread_id_t tid) const;
+ Thread * get_thread(const ModelAction *act) const;
+
+ Thread * get_current_thread() const;
+
+ void switch_from_master(Thread *thread);
+ uint64_t switch_to_master(ModelAction *act);
+
+ bool assert_bug(const char *msg, ...);
+ void assert_user_bug(const char *msg);
+
+ const model_params params;
+ void add_trace_analysis(TraceAnalysis *a) {
+ trace_analyses.push_back(a);
+ }
+
+ MEMALLOC
+private:
+ /** The scheduler to use: tracks the running/ready Threads */
+ Scheduler * const scheduler;
+ NodeStack * const node_stack;
+ ModelExecution *execution;
+
+ int execution_number;
+
+ unsigned int get_num_threads() const;
+
+ void execute_sleep_set();
+
+ bool next_execution();
+ bool should_terminate_execution();
+
+ Thread * get_next_thread();
+ void reset_to_initial_state();
+
+
+ ModelAction *diverge;
+ ModelAction *earliest_diverge;
+
+ ucontext_t system_context;
+
+ ModelVector<TraceAnalysis *> trace_analyses;
+
+ /** @brief The cumulative execution stats */
+ struct execution_stats stats;
+ void record_stats();
+ void run_trace_analyses();
+ void print_bugs() const;
+ void print_execution(bool printbugs) const;
+ void print_stats() const;
+
+ friend void user_main_wrapper();
+};
+
+extern ModelChecker *model;
+
+#endif /* __MODEL_H__ */
--- /dev/null
+#include <mutex>
+
+#include "model.h"
+#include "execution.h"
+#include "threads-model.h"
+#include "clockvector.h"
+#include "action.h"
+
+namespace std {
+
+mutex::mutex()
+{
+ state.locked = NULL;
+ thread_id_t tid = thread_current()->get_id();
+ state.alloc_tid = tid;
+ state.alloc_clock = model->get_execution()->get_cv(tid)->getClock(tid);
+}
+
+void mutex::lock()
+{
+ model->switch_to_master(new ModelAction(ATOMIC_LOCK, std::memory_order_seq_cst, this));
+}
+
+bool mutex::try_lock()
+{
+ return model->switch_to_master(new ModelAction(ATOMIC_TRYLOCK, std::memory_order_seq_cst, this));
+}
+
+void mutex::unlock()
+{
+ model->switch_to_master(new ModelAction(ATOMIC_UNLOCK, std::memory_order_seq_cst, this));
+}
+
+}
--- /dev/null
+#include <stdlib.h>
+#include <stdio.h>
+#include <dlfcn.h>
+#include <unistd.h>
+#include <string.h>
+#include <new>
+
+#include "mymemory.h"
+#include "snapshot.h"
+#include "common.h"
+#include "threads-model.h"
+#include "model.h"
+
+#define REQUESTS_BEFORE_ALLOC 1024
+
+size_t allocatedReqs[REQUESTS_BEFORE_ALLOC] = { 0 };
+int nextRequest = 0;
+int howManyFreed = 0;
+#if !USE_MPROTECT_SNAPSHOT
+static mspace sStaticSpace = NULL;
+#endif
+
+/** Non-snapshotting calloc for our use. */
+void *model_calloc(size_t count, size_t size)
+{
+#if USE_MPROTECT_SNAPSHOT
+ static void *(*callocp)(size_t count, size_t size) = NULL;
+ char *error;
+ void *ptr;
+
+ /* get address of libc malloc */
+ if (!callocp) {
+ callocp = (void * (*)(size_t, size_t))dlsym(RTLD_NEXT, "calloc");
+ if ((error = dlerror()) != NULL) {
+ fputs(error, stderr);
+ exit(EXIT_FAILURE);
+ }
+ }
+ ptr = callocp(count, size);
+ return ptr;
+#else
+ if (!sStaticSpace)
+ sStaticSpace = create_shared_mspace();
+ return mspace_calloc(sStaticSpace, count, size);
+#endif
+}
+
+/** Non-snapshotting malloc for our use. */
+void *model_malloc(size_t size)
+{
+#if USE_MPROTECT_SNAPSHOT
+ static void *(*mallocp)(size_t size) = NULL;
+ char *error;
+ void *ptr;
+
+ /* get address of libc malloc */
+ if (!mallocp) {
+ mallocp = (void * (*)(size_t))dlsym(RTLD_NEXT, "malloc");
+ if ((error = dlerror()) != NULL) {
+ fputs(error, stderr);
+ exit(EXIT_FAILURE);
+ }
+ }
+ ptr = mallocp(size);
+ return ptr;
+#else
+ if (!sStaticSpace)
+ sStaticSpace = create_shared_mspace();
+ return mspace_malloc(sStaticSpace, size);
+#endif
+}
+
+/** @brief Snapshotting malloc, for use by model-checker (not user progs) */
+void * snapshot_malloc(size_t size)
+{
+ void *tmp = mspace_malloc(model_snapshot_space, size);
+ ASSERT(tmp);
+ return tmp;
+}
+
+/** @brief Snapshotting calloc, for use by model-checker (not user progs) */
+void * snapshot_calloc(size_t count, size_t size)
+{
+ void *tmp = mspace_calloc(model_snapshot_space, count, size);
+ ASSERT(tmp);
+ return tmp;
+}
+
+/** @brief Snapshotting realloc, for use by model-checker (not user progs) */
+void *snapshot_realloc(void *ptr, size_t size)
+{
+ void *tmp = mspace_realloc(model_snapshot_space, ptr, size);
+ ASSERT(tmp);
+ return tmp;
+}
+
+/** @brief Snapshotting free, for use by model-checker (not user progs) */
+void snapshot_free(void *ptr)
+{
+ mspace_free(model_snapshot_space, ptr);
+}
+
+/** Non-snapshotting free for our use. */
+void model_free(void *ptr)
+{
+#if USE_MPROTECT_SNAPSHOT
+ static void (*freep)(void *);
+ char *error;
+
+ /* get address of libc free */
+ if (!freep) {
+ freep = (void (*)(void *))dlsym(RTLD_NEXT, "free");
+ if ((error = dlerror()) != NULL) {
+ fputs(error, stderr);
+ exit(EXIT_FAILURE);
+ }
+ }
+ freep(ptr);
+#else
+ mspace_free(sStaticSpace, ptr);
+#endif
+}
+
+/** Bootstrap allocation. Problem is that the dynamic linker calls require
+ * calloc to work and calloc requires the dynamic linker to work. */
+
+#define BOOTSTRAPBYTES 4096
+char bootstrapmemory[BOOTSTRAPBYTES];
+size_t offset = 0;
+
+void * HandleEarlyAllocationRequest(size_t sz)
+{
+ /* Align to 8 byte boundary */
+ sz = (sz + 7) & ~7;
+
+ if (sz > (BOOTSTRAPBYTES-offset)) {
+ model_print("OUT OF BOOTSTRAP MEMORY\n");
+ exit(EXIT_FAILURE);
+ }
+
+ void *pointer = (void *)&bootstrapmemory[offset];
+ offset += sz;
+ return pointer;
+}
+
+/** @brief Global mspace reference for the model-checker's snapshotting heap */
+mspace model_snapshot_space = NULL;
+
+#if USE_MPROTECT_SNAPSHOT
+
+/** @brief Global mspace reference for the user's snapshotting heap */
+mspace user_snapshot_space = NULL;
+
+/** Check whether this is bootstrapped memory that we should not free */
+static bool DontFree(void *ptr)
+{
+ return (ptr >= (&bootstrapmemory[0]) && ptr < (&bootstrapmemory[BOOTSTRAPBYTES]));
+}
+
+/**
+ * @brief The allocator function for "user" allocation
+ *
+ * Should only be used for allocations which will not disturb the allocation
+ * patterns of a user thread.
+ */
+static void * user_malloc(size_t size)
+{
+ void *tmp = mspace_malloc(user_snapshot_space, size);
+ ASSERT(tmp);
+ return tmp;
+}
+
+/**
+ * @brief Snapshotting malloc implementation for user programs
+ *
+ * Do NOT call this function from a model-checker context. Doing so may disrupt
+ * the allocation patterns of a user thread.
+ */
+void *malloc(size_t size)
+{
+ if (user_snapshot_space) {
+ /* Only perform user allocations from user context */
+ ASSERT(!model || thread_current());
+ return user_malloc(size);
+ } else
+ return HandleEarlyAllocationRequest(size);
+}
+
+/** @brief Snapshotting free implementation for user programs */
+void free(void * ptr)
+{
+ if (!DontFree(ptr))
+ mspace_free(user_snapshot_space, ptr);
+}
+
+/** @brief Snapshotting realloc implementation for user programs */
+void *realloc(void *ptr, size_t size)
+{
+ void *tmp = mspace_realloc(user_snapshot_space, ptr, size);
+ ASSERT(tmp);
+ return tmp;
+}
+
+/** @brief Snapshotting calloc implementation for user programs */
+void * calloc(size_t num, size_t size)
+{
+ if (user_snapshot_space) {
+ void *tmp = mspace_calloc(user_snapshot_space, num, size);
+ ASSERT(tmp);
+ return tmp;
+ } else {
+ void *tmp = HandleEarlyAllocationRequest(size * num);
+ memset(tmp, 0, size * num);
+ return tmp;
+ }
+}
+
+/** @brief Snapshotting allocation function for use by the Thread class only */
+void * Thread_malloc(size_t size)
+{
+ return user_malloc(size);
+}
+
+/** @brief Snapshotting free function for use by the Thread class only */
+void Thread_free(void *ptr)
+{
+ free(ptr);
+}
+
+/** @brief Snapshotting new operator for user programs */
+void * operator new(size_t size) throw(std::bad_alloc)
+{
+ return malloc(size);
+}
+
+/** @brief Snapshotting delete operator for user programs */
+void operator delete(void *p) throw()
+{
+ free(p);
+}
+
+/** @brief Snapshotting new[] operator for user programs */
+void * operator new[](size_t size) throw(std::bad_alloc)
+{
+ return malloc(size);
+}
+
+/** @brief Snapshotting delete[] operator for user programs */
+void operator delete[](void *p, size_t size)
+{
+ free(p);
+}
+
+#else /* !USE_MPROTECT_SNAPSHOT */
+
+/** @brief Snapshotting allocation function for use by the Thread class only */
+void * Thread_malloc(size_t size)
+{
+ return malloc(size);
+}
+
+/** @brief Snapshotting free function for use by the Thread class only */
+void Thread_free(void *ptr)
+{
+ free(ptr);
+}
+
+#endif /* !USE_MPROTECT_SNAPSHOT */
--- /dev/null
+/** @file mymemory.h
+ * @brief Memory allocation functions.
+ */
+
+#ifndef _MY_MEMORY_H
+#define _MY_MEMORY_H
+#include <limits>
+#include <stddef.h>
+
+#include "config.h"
+
+/** MEMALLOC declares the allocators for a class to allocate
+ * memory in the non-snapshotting heap. */
+#define MEMALLOC \
+ void * operator new(size_t size) { \
+ return model_malloc(size); \
+ } \
+ void operator delete(void *p, size_t size) { \
+ model_free(p); \
+ } \
+ void * operator new[](size_t size) { \
+ return model_malloc(size); \
+ } \
+ void operator delete[](void *p, size_t size) { \
+ model_free(p); \
+ } \
+ void * operator new(size_t size, void *p) { /* placement new */ \
+ return p; \
+ }
+
+/** SNAPSHOTALLOC declares the allocators for a class to allocate
+ * memory in the snapshotting heap. */
+#define SNAPSHOTALLOC \
+ void * operator new(size_t size) { \
+ return snapshot_malloc(size); \
+ } \
+ void operator delete(void *p, size_t size) { \
+ snapshot_free(p); \
+ } \
+ void * operator new[](size_t size) { \
+ return snapshot_malloc(size); \
+ } \
+ void operator delete[](void *p, size_t size) { \
+ snapshot_free(p); \
+ } \
+ void * operator new(size_t size, void *p) { /* placement new */ \
+ return p; \
+ }
+
+void *model_malloc(size_t size);
+void *model_calloc(size_t count, size_t size);
+void model_free(void *ptr);
+
+void * snapshot_malloc(size_t size);
+void * snapshot_calloc(size_t count, size_t size);
+void * snapshot_realloc(void *ptr, size_t size);
+void snapshot_free(void *ptr);
+
+void * Thread_malloc(size_t size);
+void Thread_free(void *ptr);
+
+/** @brief Provides a non-snapshotting allocator for use in STL classes.
+ *
+ * The code was adapted from a code example from the book The C++
+ * Standard Library - A Tutorial and Reference by Nicolai M. Josuttis,
+ * Addison-Wesley, 1999 © Copyright Nicolai M. Josuttis 1999
+ * Permission to copy, use, modify, sell and distribute this software
+ * is granted provided this copyright notice appears in all copies.
+ * This software is provided "as is" without express or implied
+ * warranty, and with no claim as to its suitability for any purpose.
+ */
+template <class T>
+class ModelAlloc {
+ public:
+ // type definitions
+ typedef T value_type;
+ typedef T* pointer;
+ typedef const T* const_pointer;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef size_t size_type;
+ typedef size_t difference_type;
+
+ // rebind allocator to type U
+ template <class U>
+ struct rebind {
+ typedef ModelAlloc<U> other;
+ };
+
+ // return address of values
+ pointer address(reference value) const {
+ return &value;
+ }
+ const_pointer address(const_reference value) const {
+ return &value;
+ }
+
+ /* constructors and destructor
+ * - nothing to do because the allocator has no state
+ */
+ ModelAlloc() throw() {
+ }
+ ModelAlloc(const ModelAlloc&) throw() {
+ }
+ template <class U>
+ ModelAlloc(const ModelAlloc<U>&) throw() {
+ }
+ ~ModelAlloc() throw() {
+ }
+
+ // return maximum number of elements that can be allocated
+ size_type max_size() const throw() {
+ return std::numeric_limits<size_t>::max() / sizeof(T);
+ }
+
+ // allocate but don't initialize num elements of type T
+ pointer allocate(size_type num, const void * = 0) {
+ pointer p = (pointer)model_malloc(num * sizeof(T));
+ return p;
+ }
+
+ // initialize elements of allocated storage p with value value
+ void construct(pointer p, const T& value) {
+ // initialize memory with placement new
+ new((void*)p)T(value);
+ }
+
+ // destroy elements of initialized storage p
+ void destroy(pointer p) {
+ // destroy objects by calling their destructor
+ p->~T();
+ }
+
+ // deallocate storage p of deleted elements
+ void deallocate(pointer p, size_type num) {
+ model_free((void*)p);
+ }
+};
+
+/** Return that all specializations of this allocator are interchangeable. */
+template <class T1, class T2>
+bool operator ==(const ModelAlloc<T1>&,
+ const ModelAlloc<T2>&) throw() {
+ return true;
+}
+
+/** Return that all specializations of this allocator are interchangeable. */
+template <class T1, class T2>
+bool operator!= (const ModelAlloc<T1>&,
+ const ModelAlloc<T2>&) throw() {
+ return false;
+}
+
+/** @brief Provides a snapshotting allocator for use in STL classes.
+ *
+ * The code was adapted from a code example from the book The C++
+ * Standard Library - A Tutorial and Reference by Nicolai M. Josuttis,
+ * Addison-Wesley, 1999 © Copyright Nicolai M. Josuttis 1999
+ * Permission to copy, use, modify, sell and distribute this software
+ * is granted provided this copyright notice appears in all copies.
+ * This software is provided "as is" without express or implied
+ * warranty, and with no claim as to its suitability for any purpose.
+ */
+template <class T>
+class SnapshotAlloc {
+ public:
+ // type definitions
+ typedef T value_type;
+ typedef T* pointer;
+ typedef const T* const_pointer;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef size_t size_type;
+ typedef size_t difference_type;
+
+ // rebind allocator to type U
+ template <class U>
+ struct rebind {
+ typedef SnapshotAlloc<U> other;
+ };
+
+ // return address of values
+ pointer address(reference value) const {
+ return &value;
+ }
+ const_pointer address(const_reference value) const {
+ return &value;
+ }
+
+ /* constructors and destructor
+ * - nothing to do because the allocator has no state
+ */
+ SnapshotAlloc() throw() {
+ }
+ SnapshotAlloc(const SnapshotAlloc&) throw() {
+ }
+ template <class U>
+ SnapshotAlloc(const SnapshotAlloc<U>&) throw() {
+ }
+ ~SnapshotAlloc() throw() {
+ }
+
+ // return maximum number of elements that can be allocated
+ size_type max_size() const throw() {
+ return std::numeric_limits<size_t>::max() / sizeof(T);
+ }
+
+ // allocate but don't initialize num elements of type T
+ pointer allocate(size_type num, const void * = 0) {
+ pointer p = (pointer)snapshot_malloc(num * sizeof(T));
+ return p;
+ }
+
+ // initialize elements of allocated storage p with value value
+ void construct(pointer p, const T& value) {
+ // initialize memory with placement new
+ new((void*)p)T(value);
+ }
+
+ // destroy elements of initialized storage p
+ void destroy(pointer p) {
+ // destroy objects by calling their destructor
+ p->~T();
+ }
+
+ // deallocate storage p of deleted elements
+ void deallocate(pointer p, size_type num) {
+ snapshot_free((void*)p);
+ }
+};
+
+/** Return that all specializations of this allocator are interchangeable. */
+template <class T1, class T2>
+bool operator ==(const SnapshotAlloc<T1>&,
+ const SnapshotAlloc<T2>&) throw() {
+ return true;
+}
+
+/** Return that all specializations of this allocator are interchangeable. */
+template <class T1, class T2>
+bool operator!= (const SnapshotAlloc<T1>&,
+ const SnapshotAlloc<T2>&) throw() {
+ return false;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+ typedef void * mspace;
+ extern void * mspace_malloc(mspace msp, size_t bytes);
+ extern void mspace_free(mspace msp, void* mem);
+ extern void * mspace_realloc(mspace msp, void* mem, size_t newsize);
+ extern void * mspace_calloc(mspace msp, size_t n_elements, size_t elem_size);
+ extern mspace create_mspace_with_base(void* base, size_t capacity, int locked);
+ extern mspace create_mspace(size_t capacity, int locked);
+
+#if USE_MPROTECT_SNAPSHOT
+ extern mspace user_snapshot_space;
+#endif
+
+ extern mspace model_snapshot_space;
+
+#ifdef __cplusplus
+}; /* end of extern "C" */
+#endif
+
+#endif /* _MY_MEMORY_H */
--- /dev/null
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+
+#include <string.h>
+
+#include "nodestack.h"
+#include "action.h"
+#include "common.h"
+#include "threads-model.h"
+#include "modeltypes.h"
+#include "execution.h"
+#include "params.h"
+
+/**
+ * @brief Node constructor
+ *
+ * Constructs a single Node for use in a NodeStack. Each Node is associated
+ * with exactly one ModelAction (exception: the first Node should be created
+ * as an empty stub, to represent the first thread "choice") and up to one
+ * parent.
+ *
+ * @param params The model-checker parameters
+ * @param act The ModelAction to associate with this Node. May be NULL.
+ * @param par The parent Node in the NodeStack. May be NULL if there is no
+ * parent.
+ * @param nthreads The number of threads which exist at this point in the
+ * execution trace.
+ */
+Node::Node(const struct model_params *params, ModelAction *act, Node *par,
+ int nthreads, Node *prevfairness) :
+ read_from_status(READ_FROM_PAST),
+ action(act),
+ params(params),
+ uninit_action(NULL),
+ parent(par),
+ num_threads(nthreads),
+ explored_children(num_threads),
+ backtrack(num_threads),
+ fairness(num_threads),
+ numBacktracks(0),
+ enabled_array(NULL),
+ read_from_past(),
+ read_from_past_idx(0),
+ read_from_promises(),
+ read_from_promise_idx(-1),
+ future_values(),
+ future_index(-1),
+ resolve_promise(),
+ resolve_promise_idx(-1),
+ relseq_break_writes(),
+ relseq_break_index(0),
+ misc_index(0),
+ misc_max(0),
+ yield_data(NULL)
+{
+ ASSERT(act);
+ act->set_node(this);
+ int currtid = id_to_int(act->get_tid());
+ int prevtid = prevfairness ? id_to_int(prevfairness->action->get_tid()) : 0;
+
+ if (get_params()->fairwindow != 0) {
+ for (int i = 0; i < num_threads; i++) {
+ ASSERT(i < ((int)fairness.size()));
+ struct fairness_info *fi = &fairness[i];
+ struct fairness_info *prevfi = (parent && i < parent->get_num_threads()) ? &parent->fairness[i] : NULL;
+ if (prevfi) {
+ *fi = *prevfi;
+ }
+ if (parent && parent->is_enabled(int_to_id(i))) {
+ fi->enabled_count++;
+ }
+ if (i == currtid) {
+ fi->turns++;
+ fi->priority = false;
+ }
+ /* Do window processing */
+ if (prevfairness != NULL) {
+ if (prevfairness->parent->is_enabled(int_to_id(i)))
+ fi->enabled_count--;
+ if (i == prevtid) {
+ fi->turns--;
+ }
+ /* Need full window to start evaluating
+ * conditions
+ * If we meet the enabled count and have no
+ * turns, give us priority */
+ if ((fi->enabled_count >= get_params()->enabledcount) &&
+ (fi->turns == 0))
+ fi->priority = true;
+ }
+ }
+ }
+}
+
+int Node::get_yield_data(int tid1, int tid2) const {
+ if (tid1<num_threads && tid2 < num_threads)
+ return yield_data[YIELD_INDEX(tid1,tid2,num_threads)];
+ else
+ return YIELD_S | YIELD_D;
+}
+
+void Node::update_yield(Scheduler * scheduler) {
+ if (yield_data==NULL)
+ yield_data=(int *) model_calloc(1, sizeof(int)*num_threads*num_threads);
+ //handle base case
+ if (parent == NULL) {
+ for(int i = 0; i < num_threads*num_threads; i++) {
+ yield_data[i] = YIELD_S | YIELD_D;
+ }
+ return;
+ }
+ int curr_tid=id_to_int(action->get_tid());
+
+ for(int u = 0; u < num_threads; u++) {
+ for(int v = 0; v < num_threads; v++) {
+ int yield_state=parent->get_yield_data(u, v);
+ bool next_enabled=scheduler->is_enabled(int_to_id(v));
+ bool curr_enabled=parent->is_enabled(int_to_id(v));
+ if (!next_enabled) {
+ //Compute intersection of ES and E
+ yield_state&=~YIELD_E;
+ //Check to see if we disabled the thread
+ if (u==curr_tid && curr_enabled)
+ yield_state|=YIELD_D;
+ }
+ yield_data[YIELD_INDEX(u, v, num_threads)]=yield_state;
+ }
+ yield_data[YIELD_INDEX(u, curr_tid, num_threads)]=(yield_data[YIELD_INDEX(u, curr_tid, num_threads)]&~YIELD_P)|YIELD_S;
+ }
+ //handle curr.yield(t) part of computation
+ if (action->is_yield()) {
+ for(int v = 0; v < num_threads; v++) {
+ int yield_state=yield_data[YIELD_INDEX(curr_tid, v, num_threads)];
+ if ((yield_state & (YIELD_E | YIELD_D)) && (!(yield_state & YIELD_S)))
+ yield_state |= YIELD_P;
+ yield_state &= YIELD_P;
+ if (scheduler->is_enabled(int_to_id(v))) {
+ yield_state|=YIELD_E;
+ }
+ yield_data[YIELD_INDEX(curr_tid, v, num_threads)]=yield_state;
+ }
+ }
+}
+
+/** @brief Node desctructor */
+Node::~Node()
+{
+ delete action;
+ if (uninit_action)
+ delete uninit_action;
+ if (enabled_array)
+ model_free(enabled_array);
+ if (yield_data)
+ model_free(yield_data);
+}
+
+/** Prints debugging info for the ModelAction associated with this Node */
+void Node::print() const
+{
+ action->print();
+ model_print(" thread status: ");
+ if (enabled_array) {
+ for (int i = 0; i < num_threads; i++) {
+ char str[20];
+ enabled_type_to_string(enabled_array[i], str);
+ model_print("[%d: %s]", i, str);
+ }
+ model_print("\n");
+ } else
+ model_print("(info not available)\n");
+ model_print(" backtrack: %s", backtrack_empty() ? "empty" : "non-empty ");
+ for (int i = 0; i < (int)backtrack.size(); i++)
+ if (backtrack[i] == true)
+ model_print("[%d]", i);
+ model_print("\n");
+
+ model_print(" read from past: %s", read_from_past_empty() ? "empty" : "non-empty ");
+ for (int i = read_from_past_idx + 1; i < (int)read_from_past.size(); i++)
+ model_print("[%d]", read_from_past[i]->get_seq_number());
+ model_print("\n");
+
+ model_print(" read-from promises: %s", read_from_promise_empty() ? "empty" : "non-empty ");
+ for (int i = read_from_promise_idx + 1; i < (int)read_from_promises.size(); i++)
+ model_print("[%d]", read_from_promises[i]->get_seq_number());
+ model_print("\n");
+
+ model_print(" future values: %s", future_value_empty() ? "empty" : "non-empty ");
+ for (int i = future_index + 1; i < (int)future_values.size(); i++)
+ model_print("[%#" PRIx64 "]", future_values[i].value);
+ model_print("\n");
+
+ model_print(" promises: %s\n", promise_empty() ? "empty" : "non-empty");
+ model_print(" misc: %s\n", misc_empty() ? "empty" : "non-empty");
+ model_print(" rel seq break: %s\n", relseq_break_empty() ? "empty" : "non-empty");
+}
+
+/****************************** threads backtracking **************************/
+
+/**
+ * Checks if the Thread associated with this thread ID has been explored from
+ * this Node already.
+ * @param tid is the thread ID to check
+ * @return true if this thread choice has been explored already, false
+ * otherwise
+ */
+bool Node::has_been_explored(thread_id_t tid) const
+{
+ int id = id_to_int(tid);
+ return explored_children[id];
+}
+
+/**
+ * Checks if the backtracking set is empty.
+ * @return true if the backtracking set is empty
+ */
+bool Node::backtrack_empty() const
+{
+ return (numBacktracks == 0);
+}
+
+void Node::explore(thread_id_t tid)
+{
+ int i = id_to_int(tid);
+ ASSERT(i < ((int)backtrack.size()));
+ if (backtrack[i]) {
+ backtrack[i] = false;
+ numBacktracks--;
+ }
+ explored_children[i] = true;
+}
+
+/**
+ * Mark the appropriate backtracking information for exploring a thread choice.
+ * @param act The ModelAction to explore
+ */
+void Node::explore_child(ModelAction *act, enabled_type_t *is_enabled)
+{
+ if (!enabled_array)
+ enabled_array = (enabled_type_t *)model_malloc(sizeof(enabled_type_t) * num_threads);
+ if (is_enabled != NULL)
+ memcpy(enabled_array, is_enabled, sizeof(enabled_type_t) * num_threads);
+ else {
+ for (int i = 0; i < num_threads; i++)
+ enabled_array[i] = THREAD_DISABLED;
+ }
+
+ explore(act->get_tid());
+}
+
+/**
+ * Records a backtracking reference for a thread choice within this Node.
+ * Provides feedback as to whether this thread choice is already set for
+ * backtracking.
+ * @return false if the thread was already set to be backtracked, true
+ * otherwise
+ */
+bool Node::set_backtrack(thread_id_t id)
+{
+ int i = id_to_int(id);
+ ASSERT(i < ((int)backtrack.size()));
+ if (backtrack[i])
+ return false;
+ backtrack[i] = true;
+ numBacktracks++;
+ return true;
+}
+
+thread_id_t Node::get_next_backtrack()
+{
+ /** @todo Find next backtrack */
+ unsigned int i;
+ for (i = 0; i < backtrack.size(); i++)
+ if (backtrack[i] == true)
+ break;
+ /* Backtrack set was empty? */
+ ASSERT(i != backtrack.size());
+
+ backtrack[i] = false;
+ numBacktracks--;
+ return int_to_id(i);
+}
+
+void Node::clear_backtracking()
+{
+ for (unsigned int i = 0; i < backtrack.size(); i++)
+ backtrack[i] = false;
+ for (unsigned int i = 0; i < explored_children.size(); i++)
+ explored_children[i] = false;
+ numBacktracks = 0;
+}
+
+/************************** end threads backtracking **************************/
+
+/*********************************** promise **********************************/
+
+/**
+ * Sets a promise to explore meeting with the given node.
+ * @param i is the promise index.
+ */
+void Node::set_promise(unsigned int i)
+{
+ if (i >= resolve_promise.size())
+ resolve_promise.resize(i + 1, false);
+ resolve_promise[i] = true;
+}
+
+/**
+ * Looks up whether a given promise should be satisfied by this node.
+ * @param i The promise index.
+ * @return true if the promise should be satisfied by the given ModelAction.
+ */
+bool Node::get_promise(unsigned int i) const
+{
+ return (i < resolve_promise.size()) && (int)i == resolve_promise_idx;
+}
+
+/**
+ * Increments to the next promise to resolve.
+ * @return true if we have a valid combination.
+ */
+bool Node::increment_promise()
+{
+ DBG();
+ if (resolve_promise.empty())
+ return false;
+ int prev_idx = resolve_promise_idx;
+ resolve_promise_idx++;
+ for ( ; resolve_promise_idx < (int)resolve_promise.size(); resolve_promise_idx++)
+ if (resolve_promise[resolve_promise_idx])
+ return true;
+ resolve_promise_idx = prev_idx;
+ return false;
+}
+
+/**
+ * Returns whether the promise set is empty.
+ * @return true if we have explored all promise combinations.
+ */
+bool Node::promise_empty() const
+{
+ for (int i = resolve_promise_idx + 1; i < (int)resolve_promise.size(); i++)
+ if (i >= 0 && resolve_promise[i])
+ return false;
+ return true;
+}
+
+/** @brief Clear any promise-resolution information for this Node */
+void Node::clear_promise_resolutions()
+{
+ resolve_promise.clear();
+ resolve_promise_idx = -1;
+}
+
+/******************************* end promise **********************************/
+
+void Node::set_misc_max(int i)
+{
+ misc_max = i;
+}
+
+int Node::get_misc() const
+{
+ return misc_index;
+}
+
+bool Node::increment_misc()
+{
+ return (misc_index < misc_max) && ((++misc_index) < misc_max);
+}
+
+bool Node::misc_empty() const
+{
+ return (misc_index + 1) >= misc_max;
+}
+
+bool Node::is_enabled(Thread *t) const
+{
+ int thread_id = id_to_int(t->get_id());
+ return thread_id < num_threads && (enabled_array[thread_id] != THREAD_DISABLED);
+}
+
+enabled_type_t Node::enabled_status(thread_id_t tid) const
+{
+ int thread_id = id_to_int(tid);
+ if (thread_id < num_threads)
+ return enabled_array[thread_id];
+ else
+ return THREAD_DISABLED;
+}
+
+bool Node::is_enabled(thread_id_t tid) const
+{
+ int thread_id = id_to_int(tid);
+ return thread_id < num_threads && (enabled_array[thread_id] != THREAD_DISABLED);
+}
+
+bool Node::has_priority(thread_id_t tid) const
+{
+ return fairness[id_to_int(tid)].priority;
+}
+
+bool Node::has_priority_over(thread_id_t tid1, thread_id_t tid2) const
+{
+ return get_yield_data(id_to_int(tid1), id_to_int(tid2)) & YIELD_P;
+}
+
+/*********************************** read from ********************************/
+
+/**
+ * Get the current state of the may-read-from set iteration
+ * @return The read-from type we should currently be checking (past or future)
+ */
+read_from_type_t Node::get_read_from_status()
+{
+ if (read_from_status == READ_FROM_PAST && read_from_past.empty())
+ increment_read_from();
+ return read_from_status;
+}
+
+/**
+ * Iterate one step in the may-read-from iteration. This includes a step in
+ * reading from the either the past or the future.
+ * @return True if there is a new read-from to explore; false otherwise
+ */
+bool Node::increment_read_from()
+{
+ clear_promise_resolutions();
+ if (increment_read_from_past()) {
+ read_from_status = READ_FROM_PAST;
+ return true;
+ } else if (increment_read_from_promise()) {
+ read_from_status = READ_FROM_PROMISE;
+ return true;
+ } else if (increment_future_value()) {
+ read_from_status = READ_FROM_FUTURE;
+ return true;
+ }
+ read_from_status = READ_FROM_NONE;
+ return false;
+}
+
+/**
+ * @return True if there are any new read-froms to explore
+ */
+bool Node::read_from_empty() const
+{
+ return read_from_past_empty() &&
+ read_from_promise_empty() &&
+ future_value_empty();
+}
+
+/**
+ * Get the total size of the may-read-from set, including both past and future
+ * values
+ * @return The size of may-read-from
+ */
+unsigned int Node::read_from_size() const
+{
+ return read_from_past.size() +
+ read_from_promises.size() +
+ future_values.size();
+}
+
+/******************************* end read from ********************************/
+
+/****************************** read from past ********************************/
+
+/** @brief Prints info about read_from_past set */
+void Node::print_read_from_past()
+{
+ for (unsigned int i = 0; i < read_from_past.size(); i++)
+ read_from_past[i]->print();
+}
+
+/**
+ * Add an action to the read_from_past set.
+ * @param act is the action to add
+ */
+void Node::add_read_from_past(const ModelAction *act)
+{
+ read_from_past.push_back(act);
+}
+
+/**
+ * Gets the next 'read_from_past' action from this Node. Only valid for a node
+ * where this->action is a 'read'.
+ * @return The first element in read_from_past
+ */
+const ModelAction * Node::get_read_from_past() const
+{
+ if (read_from_past_idx < read_from_past.size())
+ return read_from_past[read_from_past_idx];
+ else
+ return NULL;
+}
+
+const ModelAction * Node::get_read_from_past(int i) const
+{
+ return read_from_past[i];
+}
+
+int Node::get_read_from_past_size() const
+{
+ return read_from_past.size();
+}
+
+/**
+ * Checks whether the readsfrom set for this node is empty.
+ * @return true if the readsfrom set is empty.
+ */
+bool Node::read_from_past_empty() const
+{
+ return ((read_from_past_idx + 1) >= read_from_past.size());
+}
+
+/**
+ * Increments the index into the readsfrom set to explore the next item.
+ * @return Returns false if we have explored all items.
+ */
+bool Node::increment_read_from_past()
+{
+ DBG();
+ if (read_from_past_idx < read_from_past.size()) {
+ read_from_past_idx++;
+ return read_from_past_idx < read_from_past.size();
+ }
+ return false;
+}
+
+/************************** end read from past ********************************/
+
+/***************************** read_from_promises *****************************/
+
+/**
+ * Add an action to the read_from_promises set.
+ * @param reader The read which generated the Promise; we use the ModelAction
+ * instead of the Promise because the Promise does not last across executions
+ */
+void Node::add_read_from_promise(const ModelAction *reader)
+{
+ read_from_promises.push_back(reader);
+}
+
+/**
+ * Gets the next 'read-from-promise' from this Node. Only valid for a node
+ * where this->action is a 'read'.
+ * @return The current element in read_from_promises
+ */
+Promise * Node::get_read_from_promise() const
+{
+ ASSERT(read_from_promise_idx >= 0 && read_from_promise_idx < ((int)read_from_promises.size()));
+ return read_from_promises[read_from_promise_idx]->get_reads_from_promise();
+}
+
+/**
+ * Gets a particular 'read-from-promise' form this Node. Only vlaid for a node
+ * where this->action is a 'read'.
+ * @param i The index of the Promise to get
+ * @return The Promise at index i, if the Promise is still available; NULL
+ * otherwise
+ */
+Promise * Node::get_read_from_promise(int i) const
+{
+ return read_from_promises[i]->get_reads_from_promise();
+}
+
+/** @return The size of the read-from-promise set */
+int Node::get_read_from_promise_size() const
+{
+ return read_from_promises.size();
+}
+
+/**
+ * Checks whether the read_from_promises set for this node is empty.
+ * @return true if the read_from_promises set is empty.
+ */
+bool Node::read_from_promise_empty() const
+{
+ return ((read_from_promise_idx + 1) >= ((int)read_from_promises.size()));
+}
+
+/**
+ * Increments the index into the read_from_promises set to explore the next item.
+ * @return Returns false if we have explored all promises.
+ */
+bool Node::increment_read_from_promise()
+{
+ DBG();
+ if (read_from_promise_idx < ((int)read_from_promises.size())) {
+ read_from_promise_idx++;
+ return (read_from_promise_idx < ((int)read_from_promises.size()));
+ }
+ return false;
+}
+
+/************************* end read_from_promises *****************************/
+
+/****************************** future values *********************************/
+
+/**
+ * Adds a value from a weakly ordered future write to backtrack to. This
+ * operation may "fail" if the future value has already been run (within some
+ * sloppiness window of this expiration), or if the futurevalues set has
+ * reached its maximum.
+ * @see model_params.maxfuturevalues
+ *
+ * @param value is the value to backtrack to.
+ * @return True if the future value was successully added; false otherwise
+ */
+bool Node::add_future_value(struct future_value fv)
+{
+ uint64_t value = fv.value;
+ modelclock_t expiration = fv.expiration;
+ thread_id_t tid = fv.tid;
+ int idx = -1; /* Highest index where value is found */
+ for (unsigned int i = 0; i < future_values.size(); i++) {
+ if (future_values[i].value == value && future_values[i].tid == tid) {
+ if (expiration <= future_values[i].expiration)
+ return false;
+ idx = i;
+ }
+ }
+ if (idx > future_index) {
+ /* Future value hasn't been explored; update expiration */
+ future_values[idx].expiration = expiration;
+ return true;
+ } else if (idx >= 0 && expiration <= future_values[idx].expiration + get_params()->expireslop) {
+ /* Future value has been explored and is within the "sloppy" window */
+ return false;
+ }
+
+ /* Limit the size of the future-values set */
+ if (get_params()->maxfuturevalues > 0 &&
+ (int)future_values.size() >= get_params()->maxfuturevalues)
+ return false;
+
+ future_values.push_back(fv);
+ return true;
+}
+
+/**
+ * Gets the next 'future_value' from this Node. Only valid for a node where
+ * this->action is a 'read'.
+ * @return The first element in future_values
+ */
+struct future_value Node::get_future_value() const
+{
+ ASSERT(future_index >= 0 && future_index < ((int)future_values.size()));
+ return future_values[future_index];
+}
+
+/**
+ * Checks whether the future_values set for this node is empty.
+ * @return true if the future_values set is empty.
+ */
+bool Node::future_value_empty() const
+{
+ return ((future_index + 1) >= ((int)future_values.size()));
+}
+
+/**
+ * Increments the index into the future_values set to explore the next item.
+ * @return Returns false if we have explored all values.
+ */
+bool Node::increment_future_value()
+{
+ DBG();
+ if (future_index < ((int)future_values.size())) {
+ future_index++;
+ return (future_index < ((int)future_values.size()));
+ }
+ return false;
+}
+
+/************************** end future values *********************************/
+
+/*********************** breaking release sequences ***************************/
+
+/**
+ * Add a write ModelAction to the set of writes that may break the release
+ * sequence. This is used during replay exploration of pending release
+ * sequences. This Node must correspond to a release sequence fixup action.
+ *
+ * @param write The write that may break the release sequence. NULL means we
+ * allow the release sequence to synchronize.
+ */
+void Node::add_relseq_break(const ModelAction *write)
+{
+ relseq_break_writes.push_back(write);
+}
+
+/**
+ * Get the write that may break the current pending release sequence,
+ * according to the replay / divergence pattern.
+ *
+ * @return A write that may break the release sequence. If NULL, that means
+ * the release sequence should not be broken.
+ */
+const ModelAction * Node::get_relseq_break() const
+{
+ if (relseq_break_index < (int)relseq_break_writes.size())
+ return relseq_break_writes[relseq_break_index];
+ else
+ return NULL;
+}
+
+/**
+ * Increments the index into the relseq_break_writes set to explore the next
+ * item.
+ * @return Returns false if we have explored all values.
+ */
+bool Node::increment_relseq_break()
+{
+ DBG();
+ if (relseq_break_index < ((int)relseq_break_writes.size())) {
+ relseq_break_index++;
+ return (relseq_break_index < ((int)relseq_break_writes.size()));
+ }
+ return false;
+}
+
+/**
+ * @return True if all writes that may break the release sequence have been
+ * explored
+ */
+bool Node::relseq_break_empty() const
+{
+ return ((relseq_break_index + 1) >= ((int)relseq_break_writes.size()));
+}
+
+/******************* end breaking release sequences ***************************/
+
+/**
+ * Increments some behavior's index, if a new behavior is available
+ * @return True if there is a new behavior available; otherwise false
+ */
+bool Node::increment_behaviors()
+{
+ /* satisfy a different misc_index values */
+ if (increment_misc())
+ return true;
+ /* satisfy a different set of promises */
+ if (increment_promise())
+ return true;
+ /* read from a different value */
+ if (increment_read_from())
+ return true;
+ /* resolve a release sequence differently */
+ if (increment_relseq_break())
+ return true;
+ return false;
+}
+
+NodeStack::NodeStack() :
+ node_list(),
+ head_idx(-1),
+ total_nodes(0)
+{
+ total_nodes++;
+}
+
+NodeStack::~NodeStack()
+{
+ for (unsigned int i = 0; i < node_list.size(); i++)
+ delete node_list[i];
+}
+
+/**
+ * @brief Register the model-checker object with this NodeStack
+ * @param exec The execution structure for the ModelChecker
+ */
+void NodeStack::register_engine(const ModelExecution *exec)
+{
+ this->execution = exec;
+}
+
+const struct model_params * NodeStack::get_params() const
+{
+ return execution->get_params();
+}
+
+void NodeStack::print() const
+{
+ model_print("............................................\n");
+ model_print("NodeStack printing node_list:\n");
+ for (unsigned int it = 0; it < node_list.size(); it++) {
+ if ((int)it == this->head_idx)
+ model_print("vvv following action is the current iterator vvv\n");
+ node_list[it]->print();
+ }
+ model_print("............................................\n");
+}
+
+/** Note: The is_enabled set contains what actions were enabled when
+ * act was chosen. */
+ModelAction * NodeStack::explore_action(ModelAction *act, enabled_type_t *is_enabled)
+{
+ DBG();
+
+ if ((head_idx + 1) < (int)node_list.size()) {
+ head_idx++;
+ return node_list[head_idx]->get_action();
+ }
+
+ /* Record action */
+ Node *head = get_head();
+ Node *prevfairness = NULL;
+ if (head) {
+ head->explore_child(act, is_enabled);
+ if (get_params()->fairwindow != 0 && head_idx > (int)get_params()->fairwindow)
+ prevfairness = node_list[head_idx - get_params()->fairwindow];
+ }
+
+ int next_threads = execution->get_num_threads();
+ if (act->get_type() == THREAD_CREATE)
+ next_threads++;
+ node_list.push_back(new Node(get_params(), act, head, next_threads, prevfairness));
+ total_nodes++;
+ head_idx++;
+ return NULL;
+}
+
+/**
+ * Empties the stack of all trailing nodes after a given position and calls the
+ * destructor for each. This function is provided an offset which determines
+ * how many nodes (relative to the current replay state) to save before popping
+ * the stack.
+ * @param numAhead gives the number of Nodes (including this Node) to skip over
+ * before removing nodes.
+ */
+void NodeStack::pop_restofstack(int numAhead)
+{
+ /* Diverging from previous execution; clear out remainder of list */
+ unsigned int it = head_idx + numAhead;
+ for (unsigned int i = it; i < node_list.size(); i++)
+ delete node_list[i];
+ node_list.resize(it);
+ node_list.back()->clear_backtracking();
+}
+
+Node * NodeStack::get_head() const
+{
+ if (node_list.empty() || head_idx < 0)
+ return NULL;
+ return node_list[head_idx];
+}
+
+Node * NodeStack::get_next() const
+{
+ if (node_list.empty()) {
+ DEBUG("Empty\n");
+ return NULL;
+ }
+ unsigned int it = head_idx + 1;
+ if (it == node_list.size()) {
+ DEBUG("At end\n");
+ return NULL;
+ }
+ return node_list[it];
+}
+
+void NodeStack::reset_execution()
+{
+ head_idx = -1;
+}
--- /dev/null
+/** @file nodestack.h
+ * @brief Stack of operations for use in backtracking.
+*/
+
+#ifndef __NODESTACK_H__
+#define __NODESTACK_H__
+
+#include <cstddef>
+#include <inttypes.h>
+
+#include "mymemory.h"
+#include "schedule.h"
+#include "promise.h"
+#include "stl-model.h"
+
+class ModelAction;
+class Thread;
+
+struct fairness_info {
+ unsigned int enabled_count;
+ unsigned int turns;
+ bool priority;
+};
+
+/**
+ * @brief Types of read-from relations
+ *
+ * Our "may-read-from" set is composed of multiple types of reads, and we have
+ * to iterate through all of them in the backtracking search. This enumeration
+ * helps to identify which type of read-from we are currently observing.
+ */
+typedef enum {
+ READ_FROM_PAST, /**< @brief Read from a prior, existing store */
+ READ_FROM_PROMISE, /**< @brief Read from an existing promised future value */
+ READ_FROM_FUTURE, /**< @brief Read from a newly-asserted future value */
+ READ_FROM_NONE, /**< @brief A NULL state, which should not be reached */
+} read_from_type_t;
+
+#define YIELD_E 1
+#define YIELD_D 2
+#define YIELD_S 4
+#define YIELD_P 8
+#define YIELD_INDEX(tid1, tid2, num_threads) (tid1*num_threads+tid2)
+
+
+/**
+ * @brief A single node in a NodeStack
+ *
+ * Represents a single node in the NodeStack. Each Node is associated with up
+ * to one action and up to one parent node. A node holds information
+ * regarding the last action performed (the "associated action"), the thread
+ * choices that have been explored (explored_children) and should be explored
+ * (backtrack), and the actions that the last action may read from.
+ */
+class Node {
+public:
+ Node(const struct model_params *params, ModelAction *act, Node *par,
+ int nthreads, Node *prevfairness);
+ ~Node();
+ /* return true = thread choice has already been explored */
+ bool has_been_explored(thread_id_t tid) const;
+ /* return true = backtrack set is empty */
+ bool backtrack_empty() const;
+
+ void clear_backtracking();
+ void explore_child(ModelAction *act, enabled_type_t *is_enabled);
+ /* return false = thread was already in backtrack */
+ bool set_backtrack(thread_id_t id);
+ thread_id_t get_next_backtrack();
+ bool is_enabled(Thread *t) const;
+ bool is_enabled(thread_id_t tid) const;
+ enabled_type_t enabled_status(thread_id_t tid) const;
+
+ ModelAction * get_action() const { return action; }
+ void set_uninit_action(ModelAction *act) { uninit_action = act; }
+ ModelAction * get_uninit_action() const { return uninit_action; }
+
+ bool has_priority(thread_id_t tid) const;
+ void update_yield(Scheduler *);
+ bool has_priority_over(thread_id_t tid, thread_id_t tid2) const;
+ int get_num_threads() const { return num_threads; }
+ /** @return the parent Node to this Node; that is, the action that
+ * occurred previously in the stack. */
+ Node * get_parent() const { return parent; }
+
+ read_from_type_t get_read_from_status();
+ bool increment_read_from();
+ bool read_from_empty() const;
+ unsigned int read_from_size() const;
+
+ void print_read_from_past();
+ void add_read_from_past(const ModelAction *act);
+ const ModelAction * get_read_from_past() const;
+ const ModelAction * get_read_from_past(int i) const;
+ int get_read_from_past_size() const;
+
+ void add_read_from_promise(const ModelAction *reader);
+ Promise * get_read_from_promise() const;
+ Promise * get_read_from_promise(int i) const;
+ int get_read_from_promise_size() const;
+
+ bool add_future_value(struct future_value fv);
+ struct future_value get_future_value() const;
+
+ void set_promise(unsigned int i);
+ bool get_promise(unsigned int i) const;
+ bool increment_promise();
+ bool promise_empty() const;
+ void clear_promise_resolutions();
+
+ enabled_type_t *get_enabled_array() {return enabled_array;}
+
+ void set_misc_max(int i);
+ int get_misc() const;
+ bool increment_misc();
+ bool misc_empty() const;
+
+ void add_relseq_break(const ModelAction *write);
+ const ModelAction * get_relseq_break() const;
+ bool increment_relseq_break();
+ bool relseq_break_empty() const;
+
+ bool increment_behaviors();
+
+ void print() const;
+
+ MEMALLOC
+private:
+ void explore(thread_id_t tid);
+ int get_yield_data(int tid1, int tid2) const;
+ bool read_from_past_empty() const;
+ bool increment_read_from_past();
+ bool read_from_promise_empty() const;
+ bool increment_read_from_promise();
+ bool future_value_empty() const;
+ bool increment_future_value();
+ read_from_type_t read_from_status;
+ const struct model_params * get_params() const { return params; }
+
+ ModelAction * const action;
+
+ const struct model_params * const params;
+
+ /** @brief ATOMIC_UNINIT action which was created at this Node */
+ ModelAction *uninit_action;
+
+ Node * const parent;
+ const int num_threads;
+ ModelVector<bool> explored_children;
+ ModelVector<bool> backtrack;
+ ModelVector<struct fairness_info> fairness;
+ int numBacktracks;
+ enabled_type_t *enabled_array;
+
+ /**
+ * The set of past ModelActions that this the action at this Node may
+ * read from. Only meaningful if this Node represents a 'read' action.
+ */
+ ModelVector<const ModelAction *> read_from_past;
+ unsigned int read_from_past_idx;
+
+ ModelVector<const ModelAction *> read_from_promises;
+ int read_from_promise_idx;
+
+ ModelVector<struct future_value> future_values;
+ int future_index;
+
+ ModelVector<bool> resolve_promise;
+ int resolve_promise_idx;
+
+ ModelVector<const ModelAction *> relseq_break_writes;
+ int relseq_break_index;
+
+ int misc_index;
+ int misc_max;
+ int * yield_data;
+};
+
+typedef ModelVector<Node *> node_list_t;
+
+/**
+ * @brief A stack of nodes
+ *
+ * Holds a Node linked-list that can be used for holding backtracking,
+ * may-read-from, and replay information. It is used primarily as a
+ * stack-like structure, in that backtracking points and replay nodes are
+ * only removed from the top (most recent).
+ */
+class NodeStack {
+public:
+ NodeStack();
+ ~NodeStack();
+
+ void register_engine(const ModelExecution *exec);
+
+ ModelAction * explore_action(ModelAction *act, enabled_type_t * is_enabled);
+ Node * get_head() const;
+ Node * get_next() const;
+ void reset_execution();
+ void pop_restofstack(int numAhead);
+ int get_total_nodes() { return total_nodes; }
+
+ void print() const;
+
+ MEMALLOC
+private:
+ node_list_t node_list;
+
+ const struct model_params * get_params() const;
+
+ /** @brief The model-checker execution object */
+ const ModelExecution *execution;
+
+ /**
+ * @brief the index position of the current head Node
+ *
+ * This index is relative to node_list. The index should point to the
+ * current head Node. It is negative when the list is empty.
+ */
+ int head_idx;
+
+ int total_nodes;
+};
+
+#endif /* __NODESTACK_H__ */
--- /dev/null
+/** @file output.h
+ * @brief Functions for redirecting program output
+ */
+
+#ifndef __OUTPUT_H__
+#define __OUTPUT_H__
+
+#include "config.h"
+
+#ifdef CONFIG_DEBUG
+static inline void redirect_output() { }
+static inline void clear_program_output() { }
+static inline void print_program_output() { }
+#else
+void redirect_output();
+void clear_program_output();
+void print_program_output();
+#endif /* ! CONFIG_DEBUG */
+
+#endif /* __OUTPUT_H__ */
--- /dev/null
+#ifndef __PARAMS_H__
+#define __PARAMS_H__
+
+/**
+ * Model checker parameter structure. Holds run-time configuration options for
+ * the model checker.
+ */
+struct model_params {
+ int maxreads;
+ int maxfuturedelay;
+ bool yieldon;
+ bool yieldblock;
+ unsigned int fairwindow;
+ unsigned int enabledcount;
+ unsigned int bound;
+ unsigned int uninitvalue;
+
+ /** @brief Maximum number of future values that can be sent to the same
+ * read */
+ int maxfuturevalues;
+
+ /** @brief Only generate a new future value/expiration pair if the
+ * expiration time exceeds the existing one by more than the slop
+ * value */
+ unsigned int expireslop;
+
+ /** @brief Verbosity (0 = quiet; 1 = noisy; 2 = noisier) */
+ int verbose;
+
+ /** @brief Command-line argument count to pass to user program */
+ int argc;
+
+ /** @brief Command-line arguments to pass to user program */
+ char **argv;
+};
+
+#endif /* __PARAMS_H__ */
--- /dev/null
+#include "plugins.h"
+#include "scanalysis.h"
+
+ModelVector<TraceAnalysis *> * registered_analysis;
+ModelVector<TraceAnalysis *> * installed_analysis;
+
+void register_plugins() {
+ registered_analysis=new ModelVector<TraceAnalysis *>();
+ installed_analysis=new ModelVector<TraceAnalysis *>();
+ registered_analysis->push_back(new SCAnalysis());
+}
+
+ModelVector<TraceAnalysis *> * getRegisteredTraceAnalysis() {
+ return registered_analysis;
+}
+
+ModelVector<TraceAnalysis *> * getInstalledTraceAnalysis() {
+ return installed_analysis;
+}
--- /dev/null
+#ifndef PLUGINS_H
+#define PLUGINS_H
+#include "traceanalysis.h"
+#include "stl-model.h"
+
+void register_plugins();
+ModelVector<TraceAnalysis *> * getRegisteredTraceAnalysis();
+ModelVector<TraceAnalysis *> * getInstalledTraceAnalysis();
+
+#endif
--- /dev/null
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+
+#include "promise.h"
+#include "execution.h"
+#include "schedule.h"
+#include "action.h"
+#include "threads-model.h"
+
+/**
+ * @brief Promise constructor
+ * @param execution The execution which is creating this Promise
+ * @param read The read which reads from a promised future value
+ * @param fv The future value that is promised
+ */
+Promise::Promise(const ModelExecution *execution, ModelAction *read, struct future_value fv) :
+ execution(execution),
+ num_available_threads(0),
+ fv(fv),
+ readers(1, read),
+ write(NULL)
+{
+ add_thread(fv.tid);
+ eliminate_thread(read->get_tid());
+}
+
+/**
+ * Add a reader that reads from this Promise. Must be added in an order
+ * consistent with execution order.
+ *
+ * @param reader The ModelAction that reads from this promise. Must be a read.
+ * @return True if this new reader has invalidated the promise; false otherwise
+ */
+bool Promise::add_reader(ModelAction *reader)
+{
+ readers.push_back(reader);
+ return eliminate_thread(reader->get_tid());
+}
+
+/**
+ * Access a reader that read from this Promise. Readers must be inserted in
+ * order by execution order, so they can be returned in this order.
+ *
+ * @param i The index of the reader to return
+ * @return The i'th reader of this Promise
+ */
+ModelAction * Promise::get_reader(unsigned int i) const
+{
+ return i < readers.size() ? readers[i] : NULL;
+}
+
+/**
+ * Eliminate a thread which no longer can satisfy this promise. Once all
+ * enabled threads have been eliminated, this promise is unresolvable.
+ *
+ * @param tid The thread ID of the thread to eliminate
+ * @return True, if this elimination has invalidated the promise; false
+ * otherwise
+ */
+bool Promise::eliminate_thread(thread_id_t tid)
+{
+ unsigned int id = id_to_int(tid);
+ if (!thread_is_available(tid))
+ return false;
+
+ available_thread[id] = false;
+ num_available_threads--;
+ return has_failed();
+}
+
+/**
+ * Add a thread which may resolve this promise
+ *
+ * @param tid The thread ID
+ */
+void Promise::add_thread(thread_id_t tid)
+{
+ unsigned int id = id_to_int(tid);
+ if (id >= available_thread.size())
+ available_thread.resize(id + 1, false);
+ if (!available_thread[id]) {
+ available_thread[id] = true;
+ num_available_threads++;
+ }
+}
+
+/**
+ * Check if a thread is available for resolving this promise. That is, the
+ * thread must have been previously marked for resolving this promise, and it
+ * cannot have been eliminated due to synchronization, etc.
+ *
+ * @param tid Thread ID of the thread to check
+ * @return True if the thread is available; false otherwise
+ */
+bool Promise::thread_is_available(thread_id_t tid) const
+{
+ unsigned int id = id_to_int(tid);
+ if (id >= available_thread.size())
+ return false;
+ return available_thread[id];
+}
+
+/**
+ * @brief Get an upper bound on the number of available threads
+ *
+ * Gets an upper bound on the number of threads in the available threads set,
+ * useful for iterating over "thread_is_available()".
+ *
+ * @return The upper bound
+ */
+unsigned int Promise::max_available_thread_idx() const
+{
+ return available_thread.size();
+}
+
+/** @brief Print debug info about the Promise */
+void Promise::print() const
+{
+ model_print("Promised value %#" PRIx64 ", first read from thread %d, available threads to resolve: ",
+ fv.value, id_to_int(get_reader(0)->get_tid()));
+ bool failed = true;
+ for (unsigned int i = 0; i < available_thread.size(); i++)
+ if (available_thread[i]) {
+ model_print("[%d]", i);
+ failed = false;
+ }
+ if (failed)
+ model_print("(none)");
+ model_print("\n");
+}
+
+/**
+ * Check if this promise has failed. A promise can fail when all threads which
+ * could possibly satisfy the promise have been eliminated.
+ *
+ * @return True, if this promise has failed; false otherwise
+ */
+bool Promise::has_failed() const
+{
+ return num_available_threads == 0;
+}
+
+/**
+ * @brief Check if an action's thread and location are compatible for resolving
+ * this promise
+ * @param act The action to check against
+ * @return True if we are compatible; false otherwise
+ */
+bool Promise::is_compatible(const ModelAction *act) const
+{
+ return thread_is_available(act->get_tid()) && get_reader(0)->same_var(act);
+}
+
+/**
+ * @brief Check if an action's thread and location are compatible for resolving
+ * this promise, and that the promise is thread-exclusive
+ * @param act The action to check against
+ * @return True if we are compatible and exclusive; false otherwise
+ */
+bool Promise::is_compatible_exclusive(const ModelAction *act) const
+{
+ return get_num_available_threads() == 1 && is_compatible(act);
+}
+
+/**
+ * @brief Check if a store's value matches this Promise
+ * @param write The store to check
+ * @return True if the store's written value matches this Promise
+ */
+bool Promise::same_value(const ModelAction *write) const
+{
+ return get_value() == write->get_write_value();
+}
+
+/**
+ * @brief Check if a ModelAction's location matches this Promise
+ * @param act The ModelAction to check
+ * @return True if the action's location matches this Promise
+ */
+bool Promise::same_location(const ModelAction *act) const
+{
+ return get_reader(0)->same_var(act);
+}
+
+/** @brief Get this Promise's index within the execution's promise array */
+int Promise::get_index() const
+{
+ return execution->get_promise_number(this);
+}
--- /dev/null
+/** @file promise.h
+ *
+ * @brief Promise class --- tracks future obligations for execution
+ * related to weakly ordered writes.
+ */
+
+#ifndef __PROMISE_H__
+#define __PROMISE_H__
+
+#include <inttypes.h>
+
+#include "modeltypes.h"
+#include "mymemory.h"
+#include "stl-model.h"
+
+class ModelAction;
+class ModelExecution;
+
+struct future_value {
+ uint64_t value;
+ modelclock_t expiration;
+ thread_id_t tid;
+};
+
+class Promise {
+ public:
+ Promise(const ModelExecution *execution, ModelAction *read, struct future_value fv);
+ bool add_reader(ModelAction *reader);
+ ModelAction * get_reader(unsigned int i) const;
+ unsigned int get_num_readers() const { return readers.size(); }
+ bool eliminate_thread(thread_id_t tid);
+ void add_thread(thread_id_t tid);
+ bool thread_is_available(thread_id_t tid) const;
+ unsigned int max_available_thread_idx() const;
+ bool has_failed() const;
+ void set_write(const ModelAction *act) { write = act; }
+ const ModelAction * get_write() const { return write; }
+ int get_num_available_threads() const { return num_available_threads; }
+ bool is_compatible(const ModelAction *act) const;
+ bool is_compatible_exclusive(const ModelAction *act) const;
+ bool same_value(const ModelAction *write) const;
+ bool same_location(const ModelAction *act) const;
+
+ modelclock_t get_expiration() const { return fv.expiration; }
+ uint64_t get_value() const { return fv.value; }
+ struct future_value get_fv() const { return fv; }
+
+ int get_index() const;
+
+ void print() const;
+
+ bool equals(const Promise *x) const { return this == x; }
+ bool equals(const ModelAction *x) const { return false; }
+
+ SNAPSHOTALLOC
+ private:
+ /** @brief The execution which created this Promise */
+ const ModelExecution *execution;
+
+ /** @brief Thread ID(s) for thread(s) that potentially can satisfy this
+ * promise */
+ SnapVector<bool> available_thread;
+
+ int num_available_threads;
+
+ const future_value fv;
+
+ /** @brief The action(s) which read the promised future value */
+ SnapVector<ModelAction *> readers;
+
+ const ModelAction *write;
+};
+
+#endif
--- /dev/null
+#!/bin/sh
+#
+# Runs a simple test (default: ./test/userprog.o)
+# Syntax:
+# ./run.sh [test program] [OPTIONS]
+# ./run.sh [OPTIONS]
+# ./run.sh [gdb [test program]]
+#
+# If you include a 'gdb' argument, the your program will be launched with gdb.
+# You can also supply a test program argument to run something besides the
+# default program.
+#
+
+# Get the directory in which this script and the binaries are located
+BINDIR="${0%/*}"
+
+BIN=${BINDIR}/test/userprog.o
+PREFIX=
+
+export LD_LIBRARY_PATH=${BINDIR}
+# For Mac OSX
+export DYLD_LIBRARY_PATH=${BINDIR}
+
+[ $# -gt 0 ] && [ "$1" = "gdb" ] && PREFIX=gdb && shift
+[ $# -gt 0 ] && [ -e "$1" ] && BIN="$1" && shift
+
+set -xe
+$PREFIX $BIN $@
--- /dev/null
+#include "scanalysis.h"
+#include "action.h"
+#include "threads-model.h"
+#include "clockvector.h"
+#include "execution.h"
+#include <sys/time.h>
+
+
+SCAnalysis::SCAnalysis() :
+ cvmap(),
+ cyclic(false),
+ badrfset(),
+ lastwrmap(),
+ threadlists(1),
+ execution(NULL),
+ print_always(false),
+ print_buggy(true),
+ print_nonsc(false),
+ time(false),
+ stats((struct sc_statistics *)model_calloc(1, sizeof(struct sc_statistics)))
+{
+}
+
+SCAnalysis::~SCAnalysis() {
+ delete(stats);
+}
+
+void SCAnalysis::setExecution(ModelExecution * execution) {
+ this->execution=execution;
+}
+
+const char * SCAnalysis::name() {
+ const char * name = "SC";
+ return name;
+}
+
+void SCAnalysis::finish() {
+ if (time)
+ model_print("Elapsed time in usec %llu\n", stats->elapsedtime);
+ model_print("SC count: %u\n", stats->sccount);
+ model_print("Non-SC count: %u\n", stats->nonsccount);
+}
+
+bool SCAnalysis::option(char * opt) {
+ if (strcmp(opt, "verbose")==0) {
+ print_always=true;
+ return false;
+ } else if (strcmp(opt, "buggy")==0) {
+ return false;
+ } else if (strcmp(opt, "quiet")==0) {
+ print_buggy=false;
+ return false;
+ } else if (strcmp(opt, "nonsc")==0) {
+ print_nonsc=true;
+ return false;
+ } else if (strcmp(opt, "time")==0) {
+ time=true;
+ return false;
+ } else if (strcmp(opt, "help") != 0) {
+ model_print("Unrecognized option: %s\n", opt);
+ }
+
+ model_print("SC Analysis options\n");
+ model_print("verbose -- print all feasible executions\n");
+ model_print("buggy -- print only buggy executions (default)\n");
+ model_print("nonsc -- print non-sc execution\n");
+ model_print("quiet -- print nothing\n");
+ model_print("time -- time execution of scanalysis\n");
+ model_print("\n");
+
+ return true;
+}
+
+void SCAnalysis::print_list(action_list_t *list) {
+ model_print("---------------------------------------------------------------------\n");
+ if (cyclic)
+ model_print("Not SC\n");
+ unsigned int hash = 0;
+
+ for (action_list_t::iterator it = list->begin(); it != list->end(); it++) {
+ const ModelAction *act = *it;
+ if (act->get_seq_number() > 0) {
+ if (badrfset.contains(act))
+ model_print("BRF ");
+ act->print();
+ if (badrfset.contains(act)) {
+ model_print("Desired Rf: %u \n", badrfset.get(act)->get_seq_number());
+ }
+ }
+ hash = hash ^ (hash << 3) ^ ((*it)->hash());
+ }
+ model_print("HASH %u\n", hash);
+ model_print("---------------------------------------------------------------------\n");
+}
+
+void SCAnalysis::analyze(action_list_t *actions) {
+
+ struct timeval start;
+ struct timeval finish;
+ if (time)
+ gettimeofday(&start, NULL);
+ action_list_t *list = generateSC(actions);
+ check_rf(list);
+ if (print_always || (print_buggy && execution->have_bug_reports())|| (print_nonsc && cyclic))
+ print_list(list);
+ if (time) {
+ gettimeofday(&finish, NULL);
+ stats->elapsedtime+=((finish.tv_sec*1000000+finish.tv_usec)-(start.tv_sec*1000000+start.tv_usec));
+ }
+ update_stats();
+}
+
+void SCAnalysis::update_stats() {
+ if (cyclic) {
+ stats->nonsccount++;
+ } else {
+ stats->sccount++;
+ }
+}
+
+void SCAnalysis::check_rf(action_list_t *list) {
+ for (action_list_t::iterator it = list->begin(); it != list->end(); it++) {
+ const ModelAction *act = *it;
+ if (act->is_read()) {
+ if (act->get_reads_from() != lastwrmap.get(act->get_location()))
+ badrfset.put(act, lastwrmap.get(act->get_location()));
+ }
+ if (act->is_write())
+ lastwrmap.put(act->get_location(), act);
+ }
+}
+
+bool SCAnalysis::merge(ClockVector *cv, const ModelAction *act, const ModelAction *act2) {
+ ClockVector *cv2 = cvmap.get(act2);
+ if (cv2 == NULL)
+ return true;
+ if (cv2->getClock(act->get_tid()) >= act->get_seq_number() && act->get_seq_number() != 0) {
+ cyclic = true;
+ //refuse to introduce cycles into clock vectors
+ return false;
+ }
+
+ return cv->merge(cv2);
+}
+
+int SCAnalysis::getNextActions(ModelAction ** array) {
+ int count=0;
+
+ for (int t = 0; t <= maxthreads; t++) {
+ action_list_t *tlt = &threadlists[t];
+ if (tlt->empty())
+ continue;
+ ModelAction *act = tlt->front();
+ ClockVector *cv = cvmap.get(act);
+
+ /* Find the earliest in SC ordering */
+ for (int i = 0; i <= maxthreads; i++) {
+ if ( i == t )
+ continue;
+ action_list_t *threadlist = &threadlists[i];
+ if (threadlist->empty())
+ continue;
+ ModelAction *first = threadlist->front();
+ if (cv->synchronized_since(first)) {
+ act = NULL;
+ break;
+ }
+ }
+ if (act != NULL) {
+ array[count++]=act;
+ }
+ }
+ if (count != 0)
+ return count;
+ for (int t = 0; t <= maxthreads; t++) {
+ action_list_t *tlt = &threadlists[t];
+ if (tlt->empty())
+ continue;
+ ModelAction *act = tlt->front();
+ ClockVector *cv = act->get_cv();
+
+ /* Find the earliest in SC ordering */
+ for (int i = 0; i <= maxthreads; i++) {
+ if ( i == t )
+ continue;
+ action_list_t *threadlist = &threadlists[i];
+ if (threadlist->empty())
+ continue;
+ ModelAction *first = threadlist->front();
+ if (cv->synchronized_since(first)) {
+ act = NULL;
+ break;
+ }
+ }
+ if (act != NULL) {
+ array[count++]=act;
+ }
+ }
+
+ ASSERT(count==0 || cyclic);
+
+ return count;
+}
+
+ModelAction * SCAnalysis::pruneArray(ModelAction **array,int count) {
+ /* No choice */
+ if (count == 1)
+ return array[0];
+
+ /* Choose first non-write action */
+ ModelAction *nonwrite=NULL;
+ for(int i=0;i<count;i++) {
+ if (!array[i]->is_write())
+ if (nonwrite==NULL || nonwrite->get_seq_number() > array[i]->get_seq_number())
+ nonwrite = array[i];
+ }
+ if (nonwrite != NULL)
+ return nonwrite;
+
+ /* Look for non-conflicting action */
+ ModelAction *nonconflict=NULL;
+ for(int a=0;a<count;a++) {
+ ModelAction *act=array[a];
+ for (int i = 0; i <= maxthreads && act != NULL; i++) {
+ thread_id_t tid = int_to_id(i);
+ if (tid == act->get_tid())
+ continue;
+
+ action_list_t *list = &threadlists[id_to_int(tid)];
+ for (action_list_t::iterator rit = list->begin(); rit != list->end(); rit++) {
+ ModelAction *write = *rit;
+ if (!write->is_write())
+ continue;
+ ClockVector *writecv = cvmap.get(write);
+ if (writecv->synchronized_since(act))
+ break;
+ if (write->get_location() == act->get_location()) {
+ //write is sc after act
+ act = NULL;
+ break;
+ }
+ }
+ }
+ if (act != NULL) {
+ if (nonconflict == NULL || nonconflict->get_seq_number() > act->get_seq_number())
+ nonconflict=act;
+ }
+ }
+ return nonconflict;
+}
+
+action_list_t * SCAnalysis::generateSC(action_list_t *list) {
+ int numactions=buildVectors(list);
+ computeCV(list);
+
+ action_list_t *sclist = new action_list_t();
+ ModelAction **array = (ModelAction **)model_calloc(1, (maxthreads + 1) * sizeof(ModelAction *));
+ int * choices = (int *) model_calloc(1, sizeof(int)*numactions);
+ int endchoice = 0;
+ int currchoice = 0;
+ int lastchoice = -1;
+ while (true) {
+ int numActions = getNextActions(array);
+ if (numActions == 0)
+ break;
+ ModelAction * act=pruneArray(array, numActions);
+ if (act == NULL) {
+ if (currchoice < endchoice) {
+ act = array[choices[currchoice]];
+ //check whether there is still another option
+ if ((choices[currchoice]+1)<numActions)
+ lastchoice=currchoice;
+ currchoice++;
+ } else {
+ act = array[0];
+ choices[currchoice]=0;
+ if (numActions>1)
+ lastchoice=currchoice;
+ currchoice++;
+ }
+ }
+ thread_id_t tid = act->get_tid();
+ //remove action
+ threadlists[id_to_int(tid)].pop_front();
+ //add ordering constraints from this choice
+ if (updateConstraints(act)) {
+ //propagate changes if we have them
+ bool prevc=cyclic;
+ computeCV(list);
+ if (!prevc && cyclic) {
+ model_print("ROLLBACK in SC\n");
+ //check whether we have another choice
+ if (lastchoice != -1) {
+ //have to reset everything
+ choices[lastchoice]++;
+ endchoice=lastchoice+1;
+ currchoice=0;
+ lastchoice=-1;
+ reset(list);
+ buildVectors(list);
+ computeCV(list);
+ sclist->clear();
+ continue;
+ }
+ }
+ }
+ //add action to end
+ sclist->push_back(act);
+ }
+ model_free(array);
+ return sclist;
+}
+
+int SCAnalysis::buildVectors(action_list_t *list) {
+ maxthreads = 0;
+ int numactions = 0;
+ for (action_list_t::iterator it = list->begin(); it != list->end(); it++) {
+ ModelAction *act = *it;
+ numactions++;
+ int threadid = id_to_int(act->get_tid());
+ if (threadid > maxthreads) {
+ threadlists.resize(threadid + 1);
+ maxthreads = threadid;
+ }
+ threadlists[threadid].push_back(act);
+ }
+ return numactions;
+}
+
+void SCAnalysis::reset(action_list_t *list) {
+ for (int t = 0; t <= maxthreads; t++) {
+ action_list_t *tlt = &threadlists[t];
+ tlt->clear();
+ }
+ for (action_list_t::iterator it = list->begin(); it != list->end(); it++) {
+ ModelAction *act = *it;
+ delete cvmap.get(act);
+ cvmap.put(act, NULL);
+ }
+
+ cyclic=false;
+}
+
+bool SCAnalysis::updateConstraints(ModelAction *act) {
+ bool changed = false;
+ for (int i = 0; i <= maxthreads; i++) {
+ thread_id_t tid = int_to_id(i);
+ if (tid == act->get_tid())
+ continue;
+
+ action_list_t *list = &threadlists[id_to_int(tid)];
+ for (action_list_t::iterator rit = list->begin(); rit != list->end(); rit++) {
+ ModelAction *write = *rit;
+ if (!write->is_write())
+ continue;
+ ClockVector *writecv = cvmap.get(write);
+ if (writecv->synchronized_since(act))
+ break;
+ if (write->get_location() == act->get_location()) {
+ //write is sc after act
+ merge(writecv, write, act);
+ changed = true;
+ break;
+ }
+ }
+ }
+ return changed;
+}
+
+bool SCAnalysis::processRead(ModelAction *read, ClockVector *cv) {
+ bool changed = false;
+
+ /* Merge in the clock vector from the write */
+ const ModelAction *write = read->get_reads_from();
+ ClockVector *writecv = cvmap.get(write);
+ changed |= merge(cv, read, write) && (*read < *write);
+
+ for (int i = 0; i <= maxthreads; i++) {
+ thread_id_t tid = int_to_id(i);
+ if (tid == read->get_tid())
+ continue;
+ if (tid == write->get_tid())
+ continue;
+ action_list_t *list = execution->get_actions_on_obj(read->get_location(), tid);
+ if (list == NULL)
+ continue;
+ for (action_list_t::reverse_iterator rit = list->rbegin(); rit != list->rend(); rit++) {
+ ModelAction *write2 = *rit;
+ if (!write2->is_write())
+ continue;
+
+ ClockVector *write2cv = cvmap.get(write2);
+ if (write2cv == NULL)
+ continue;
+
+ /* write -sc-> write2 &&
+ write -rf-> R =>
+ R -sc-> write2 */
+ if (write2cv->synchronized_since(write)) {
+ changed |= merge(write2cv, write2, read);
+ }
+
+ //looking for earliest write2 in iteration to satisfy this
+ /* write2 -sc-> R &&
+ write -rf-> R =>
+ write2 -sc-> write */
+ if (cv->synchronized_since(write2)) {
+ changed |= writecv == NULL || merge(writecv, write, write2);
+ break;
+ }
+ }
+ }
+ return changed;
+}
+
+void SCAnalysis::computeCV(action_list_t *list) {
+ bool changed = true;
+ bool firsttime = true;
+ ModelAction **last_act = (ModelAction **)model_calloc(1, (maxthreads + 1) * sizeof(ModelAction *));
+ while (changed) {
+ changed = changed&firsttime;
+ firsttime = false;
+
+ for (action_list_t::iterator it = list->begin(); it != list->end(); it++) {
+ ModelAction *act = *it;
+ ModelAction *lastact = last_act[id_to_int(act->get_tid())];
+ if (act->is_thread_start())
+ lastact = execution->get_thread(act)->get_creation();
+ last_act[id_to_int(act->get_tid())] = act;
+ ClockVector *cv = cvmap.get(act);
+ if (cv == NULL) {
+ cv = new ClockVector(NULL, act);
+ cvmap.put(act, cv);
+ }
+ if (lastact != NULL) {
+ merge(cv, act, lastact);
+ }
+ if (act->is_thread_join()) {
+ Thread *joinedthr = act->get_thread_operand();
+ ModelAction *finish = execution->get_last_action(joinedthr->get_id());
+ changed |= merge(cv, act, finish);
+ }
+ if (act->is_read()) {
+ changed |= processRead(act, cv);
+ }
+ }
+ /* Reset the last action array */
+ if (changed) {
+ bzero(last_act, (maxthreads + 1) * sizeof(ModelAction *));
+ }
+ }
+ model_free(last_act);
+}
--- /dev/null
+#ifndef SCANALYSIS_H
+#define SCANALYSIS_H
+#include "traceanalysis.h"
+#include "hashtable.h"
+
+struct sc_statistics {
+ unsigned long long elapsedtime;
+ unsigned int sccount;
+ unsigned int nonsccount;
+};
+
+class SCAnalysis : public TraceAnalysis {
+ public:
+ SCAnalysis();
+ ~SCAnalysis();
+ virtual void setExecution(ModelExecution * execution);
+ virtual void analyze(action_list_t *);
+ virtual const char * name();
+ virtual bool option(char *);
+ virtual void finish();
+
+
+ SNAPSHOTALLOC
+ private:
+ void update_stats();
+ void print_list(action_list_t *list);
+ int buildVectors(action_list_t *);
+ bool updateConstraints(ModelAction *act);
+ void computeCV(action_list_t *);
+ action_list_t * generateSC(action_list_t *);
+ bool processRead(ModelAction *read, ClockVector *cv);
+ int getNextActions(ModelAction **array);
+ bool merge(ClockVector *cv, const ModelAction *act, const ModelAction *act2);
+ void check_rf(action_list_t *list);
+ void reset(action_list_t *list);
+ ModelAction* pruneArray(ModelAction**, int);
+
+ int maxthreads;
+ HashTable<const ModelAction *, ClockVector *, uintptr_t, 4 > cvmap;
+ bool cyclic;
+ HashTable<const ModelAction *, const ModelAction *, uintptr_t, 4 > badrfset;
+ HashTable<void *, const ModelAction *, uintptr_t, 4 > lastwrmap;
+ SnapVector<action_list_t> threadlists;
+ ModelExecution *execution;
+ bool print_always;
+ bool print_buggy;
+ bool print_nonsc;
+ bool time;
+ struct sc_statistics *stats;
+};
+#endif
--- /dev/null
+#include <string.h>
+#include <stdlib.h>
+
+#include "threads-model.h"
+#include "schedule.h"
+#include "common.h"
+#include "model.h"
+#include "nodestack.h"
+#include "execution.h"
+
+/**
+ * Format an "enabled_type_t" for printing
+ * @param e The type to format
+ * @param str The output character array
+ */
+void enabled_type_to_string(enabled_type_t e, char *str)
+{
+ const char *res;
+ switch (e) {
+ case THREAD_DISABLED:
+ res = "disabled";
+ break;
+ case THREAD_ENABLED:
+ res = "enabled";
+ break;
+ case THREAD_SLEEP_SET:
+ res = "sleep";
+ break;
+ default:
+ ASSERT(0);
+ res = NULL;
+ break;
+ }
+ strcpy(str, res);
+}
+
+/** Constructor */
+Scheduler::Scheduler() :
+ execution(NULL),
+ enabled(NULL),
+ enabled_len(0),
+ curr_thread_index(0),
+ current(NULL)
+{
+}
+
+/**
+ * @brief Register the ModelExecution engine
+ * @param execution The ModelExecution which is controlling execution
+ */
+void Scheduler::register_engine(ModelExecution *execution)
+{
+ this->execution = execution;
+}
+
+void Scheduler::set_enabled(Thread *t, enabled_type_t enabled_status) {
+ int threadid = id_to_int(t->get_id());
+ if (threadid >= enabled_len) {
+ enabled_type_t *new_enabled = (enabled_type_t *)snapshot_malloc(sizeof(enabled_type_t) * (threadid + 1));
+ memset(&new_enabled[enabled_len], 0, (threadid + 1 - enabled_len) * sizeof(enabled_type_t));
+ if (enabled != NULL) {
+ memcpy(new_enabled, enabled, enabled_len * sizeof(enabled_type_t));
+ snapshot_free(enabled);
+ }
+ enabled = new_enabled;
+ enabled_len = threadid + 1;
+ }
+ enabled[threadid] = enabled_status;
+ if (enabled_status == THREAD_DISABLED)
+ execution->check_promises_thread_disabled();
+}
+
+/**
+ * @brief Check if a Thread is currently enabled
+ *
+ * Check if a Thread is currently enabled. "Enabled" includes both
+ * THREAD_ENABLED and THREAD_SLEEP_SET.
+ * @param t The Thread to check
+ * @return True if the Thread is currently enabled
+ */
+bool Scheduler::is_enabled(const Thread *t) const
+{
+ return is_enabled(t->get_id());
+}
+
+/**
+ * @brief Check if a Thread is currently enabled
+ *
+ * Check if a Thread is currently enabled. "Enabled" includes both
+ * THREAD_ENABLED and THREAD_SLEEP_SET.
+ * @param tid The ID of the Thread to check
+ * @return True if the Thread is currently enabled
+ */
+bool Scheduler::is_enabled(thread_id_t tid) const
+{
+ int i = id_to_int(tid);
+ return (i >= enabled_len) ? false : (enabled[i] != THREAD_DISABLED);
+}
+
+/**
+ * @brief Check if a Thread is currently in the sleep set
+ * @param t The Thread to check
+ * @return True if the Thread is currently enabled
+ */
+bool Scheduler::is_sleep_set(const Thread *t) const
+{
+ return get_enabled(t) == THREAD_SLEEP_SET;
+}
+
+/**
+ * @brief Check if execution is stuck with no enabled threads and some sleeping
+ * thread
+ * @return True if no threads are enabled an some thread is in the sleep set;
+ * false otherwise
+ */
+bool Scheduler::all_threads_sleeping() const
+{
+ bool sleeping = false;
+ for (int i = 0; i < enabled_len; i++)
+ if (enabled[i] == THREAD_ENABLED)
+ return false;
+ else if (enabled[i] == THREAD_SLEEP_SET)
+ sleeping = true;
+ return sleeping;
+}
+
+enabled_type_t Scheduler::get_enabled(const Thread *t) const
+{
+ int id = id_to_int(t->get_id());
+ ASSERT(id < enabled_len);
+ return enabled[id];
+}
+
+void Scheduler::update_sleep_set(Node *n) {
+ enabled_type_t *enabled_array = n->get_enabled_array();
+ for (int i = 0; i < enabled_len; i++) {
+ if (enabled_array[i] == THREAD_SLEEP_SET) {
+ enabled[i] = THREAD_SLEEP_SET;
+ }
+ }
+}
+
+/**
+ * Add a Thread to the sleep set.
+ * @param t The Thread to add
+ */
+void Scheduler::add_sleep(Thread *t)
+{
+ DEBUG("thread %d\n", id_to_int(t->get_id()));
+ set_enabled(t, THREAD_SLEEP_SET);
+}
+
+/**
+ * Remove a Thread from the sleep set.
+ * @param t The Thread to remove
+ */
+void Scheduler::remove_sleep(Thread *t)
+{
+ DEBUG("thread %d\n", id_to_int(t->get_id()));
+ set_enabled(t, THREAD_ENABLED);
+}
+
+/**
+ * Add a Thread to the scheduler's ready list.
+ * @param t The Thread to add
+ */
+void Scheduler::add_thread(Thread *t)
+{
+ DEBUG("thread %d\n", id_to_int(t->get_id()));
+ ASSERT(!t->is_model_thread());
+ set_enabled(t, THREAD_ENABLED);
+}
+
+/**
+ * Remove a given Thread from the scheduler.
+ * @param t The Thread to remove
+ */
+void Scheduler::remove_thread(Thread *t)
+{
+ if (current == t)
+ current = NULL;
+ set_enabled(t, THREAD_DISABLED);
+}
+
+/**
+ * Prevent a Thread from being scheduled. The sleeping Thread should be
+ * re-awoken via Scheduler::wake.
+ * @param thread The Thread that should sleep
+ */
+void Scheduler::sleep(Thread *t)
+{
+ set_enabled(t, THREAD_DISABLED);
+ t->set_state(THREAD_BLOCKED);
+}
+
+/**
+ * Wake a Thread up that was previously waiting (see Scheduler::wait)
+ * @param t The Thread to wake up
+ */
+void Scheduler::wake(Thread *t)
+{
+ ASSERT(!t->is_model_thread());
+ set_enabled(t, THREAD_ENABLED);
+ t->set_state(THREAD_READY);
+}
+
+/**
+ * @brief Select a Thread to run via round-robin
+ *
+ * @param n The current Node, holding priority information for the next thread
+ * selection
+ *
+ * @return The next Thread to run
+ */
+Thread * Scheduler::select_next_thread(Node *n)
+{
+ int old_curr_thread = curr_thread_index;
+
+ bool have_enabled_thread_with_priority = false;
+ if (model->params.fairwindow != 0) {
+ for (int i = 0; i < enabled_len; i++) {
+ thread_id_t tid = int_to_id(i);
+ if (n->has_priority(tid)) {
+ DEBUG("Node (tid %d) has priority\n", i);
+ if (enabled[i] != THREAD_DISABLED)
+ have_enabled_thread_with_priority = true;
+ }
+ }
+ }
+
+ for (int i = 0; i < enabled_len; i++) {
+ curr_thread_index = (old_curr_thread + i + 1) % enabled_len;
+ thread_id_t curr_tid = int_to_id(curr_thread_index);
+ if (model->params.yieldon) {
+ bool bad_thread = false;
+ for (int j = 0; j < enabled_len; j++) {
+ thread_id_t tother = int_to_id(j);
+ if ((enabled[j] != THREAD_DISABLED) && n->has_priority_over(curr_tid, tother)) {
+ bad_thread=true;
+ break;
+ }
+ }
+ if (bad_thread)
+ continue;
+ }
+
+ if (enabled[curr_thread_index] == THREAD_ENABLED &&
+ (!have_enabled_thread_with_priority || n->has_priority(curr_tid))) {
+ return model->get_thread(curr_tid);
+ }
+ }
+
+ /* No thread was enabled */
+ return NULL;
+}
+
+void Scheduler::set_scheduler_thread(thread_id_t tid) {
+ curr_thread_index=id_to_int(tid);
+}
+
+/**
+ * @brief Set the current "running" Thread
+ * @param t Thread to run
+ */
+void Scheduler::set_current_thread(Thread *t)
+{
+ ASSERT(!t || !t->is_model_thread());
+
+ current = t;
+ if (DBG_ENABLED())
+ print();
+}
+
+/**
+ * @return The currently-running Thread
+ */
+Thread * Scheduler::get_current_thread() const
+{
+ ASSERT(!current || !current->is_model_thread());
+ return current;
+}
+
+/**
+ * Print debugging information about the current state of the scheduler. Only
+ * prints something if debugging is enabled.
+ */
+void Scheduler::print() const
+{
+ int curr_id = current ? id_to_int(current->get_id()) : -1;
+
+ model_print("Scheduler: ");
+ for (int i = 0; i < enabled_len; i++) {
+ char str[20];
+ enabled_type_to_string(enabled[i], str);
+ model_print("[%i: %s%s]", i, i == curr_id ? "current, " : "", str);
+ }
+ model_print("\n");
+}
--- /dev/null
+/** @file schedule.h
+ * @brief Thread scheduler.
+ */
+
+#ifndef __SCHEDULE_H__
+#define __SCHEDULE_H__
+
+#include "mymemory.h"
+#include "modeltypes.h"
+
+/* Forward declaration */
+class Thread;
+class Node;
+class ModelExecution;
+
+typedef enum enabled_type {
+ THREAD_DISABLED,
+ THREAD_ENABLED,
+ THREAD_SLEEP_SET
+} enabled_type_t;
+
+void enabled_type_to_string(enabled_type_t e, char *str);
+
+/** @brief The Scheduler class performs the mechanics of Thread execution
+ * scheduling. */
+class Scheduler {
+public:
+ Scheduler();
+ void register_engine(ModelExecution *execution);
+
+ void add_thread(Thread *t);
+ void remove_thread(Thread *t);
+ void sleep(Thread *t);
+ void wake(Thread *t);
+ Thread * select_next_thread(Node *n);
+ void set_current_thread(Thread *t);
+ Thread * get_current_thread() const;
+ void print() const;
+ enabled_type_t * get_enabled_array() const { return enabled; };
+ void remove_sleep(Thread *t);
+ void add_sleep(Thread *t);
+ enabled_type_t get_enabled(const Thread *t) const;
+ void update_sleep_set(Node *n);
+ bool is_enabled(const Thread *t) const;
+ bool is_enabled(thread_id_t tid) const;
+ bool is_sleep_set(const Thread *t) const;
+ bool all_threads_sleeping() const;
+ void set_scheduler_thread(thread_id_t tid);
+
+ SNAPSHOTALLOC
+private:
+ ModelExecution *execution;
+ /** The list of available Threads that are not currently running */
+ enabled_type_t *enabled;
+ int enabled_len;
+ int curr_thread_index;
+ void set_enabled(Thread *t, enabled_type_t enabled_status);
+
+ /** The currently-running Thread */
+ Thread *current;
+};
+
+#endif /* __SCHEDULE_H__ */
--- /dev/null
+#include <stdlib.h>
+#include <unistd.h>
+#include <cstring>
+#include <inttypes.h>
+
+#include "snapshot-interface.h"
+#include "snapshot.h"
+#include "common.h"
+#include "mymemory.h"
+#include "stl-model.h"
+
+/* MYBINARYNAME only works because our pathname usually includes 'model' (e.g.,
+ * /.../model-checker/test/userprog.o) */
+#define MYBINARYNAME "model"
+#define MAPFILE "/proc/self/maps"
+
+struct snapshot_entry {
+ snapshot_entry(snapshot_id id, int idx) : snapshotid(id), index(idx) { }
+ snapshot_id snapshotid;
+ int index;
+ MEMALLOC
+};
+
+class SnapshotStack {
+ public:
+ int backTrackBeforeStep(int seq_index);
+ void snapshotStep(int seq_index);
+
+ MEMALLOC
+ private:
+ ModelVector<struct snapshot_entry> stack;
+};
+
+static SnapshotStack *snap_stack;
+
+#ifdef MAC
+/** The SnapshotGlobalSegments function computes the memory regions
+ * that may contain globals and then configures the snapshotting
+ * library to snapshot them.
+ */
+static void SnapshotGlobalSegments()
+{
+ int pid = getpid();
+ char buf[9000], execname[100];
+ FILE *map;
+
+ sprintf(execname, "vmmap -interleaved %d", pid);
+ map = popen(execname, "r");
+
+ if (!map) {
+ perror("popen");
+ exit(EXIT_FAILURE);
+ }
+
+ /* Wait for correct part */
+ while (fgets(buf, sizeof(buf), map)) {
+ if (strstr(buf, "==== regions for process"))
+ break;
+ }
+
+ while (fgets(buf, sizeof(buf), map)) {
+ char regionname[200] = "";
+ char type[23];
+ char smstr[23];
+ char r, w, x;
+ char mr, mw, mx;
+ int size;
+ void *begin, *end;
+
+ //Skip out at the end of the section
+ if (buf[0] == '\n')
+ break;
+
+ sscanf(buf, "%22s %p-%p [%5dK] %c%c%c/%c%c%c SM=%3s %200s\n", type, &begin, &end, &size, &r, &w, &x, &mr, &mw, &mx, smstr, regionname);
+
+ if (w == 'w' && strstr(regionname, MYBINARYNAME)) {
+ size_t len = ((uintptr_t)end - (uintptr_t)begin) / PAGESIZE;
+ if (len != 0)
+ snapshot_add_memory_region(begin, len);
+ }
+ }
+ pclose(map);
+}
+#else
+
+static void get_binary_name(char *buf, size_t len)
+{
+ ssize_t size = readlink("/proc/self/exe", buf, len);
+ if (size < 0) {
+ perror("readlink");
+ exit(EXIT_FAILURE);
+ }
+
+ /* Terminate string */
+ if ((size_t)size > len)
+ size = len;
+ buf[size] = '\0';
+}
+
+/** The SnapshotGlobalSegments function computes the memory regions
+ * that may contain globals and then configures the snapshotting
+ * library to snapshot them.
+ */
+static void SnapshotGlobalSegments()
+{
+ char buf[9000];
+ char binary_name[800];
+ FILE *map;
+
+ map = fopen(MAPFILE, "r");
+ if (!map) {
+ perror("fopen");
+ exit(EXIT_FAILURE);
+ }
+ get_binary_name(binary_name, sizeof(binary_name));
+ while (fgets(buf, sizeof(buf), map)) {
+ char regionname[200] = "";
+ char r, w, x, p;
+ void *begin, *end;
+
+ sscanf(buf, "%p-%p %c%c%c%c %*x %*x:%*x %*u %200s\n", &begin, &end, &r, &w, &x, &p, regionname);
+ if (w == 'w' && strstr(regionname, binary_name)) {
+ size_t len = ((uintptr_t)end - (uintptr_t)begin) / PAGESIZE;
+ if (len != 0)
+ snapshot_add_memory_region(begin, len);
+ DEBUG("%55s: %18p - %18p\t%c%c%c%c\n", regionname, begin, end, r, w, x, p);
+ }
+ }
+ fclose(map);
+}
+#endif
+
+/** This method returns to the last snapshot before the inputted
+ * sequence number. This function must be called from the model
+ * checking thread and not from a snapshotted stack.
+ * @param seqindex is the sequence number to rollback before.
+ * @return is the sequence number we actually rolled back to.
+ */
+int SnapshotStack::backTrackBeforeStep(int seqindex)
+{
+ int i;
+ for (i = (int)stack.size() - 1; i >= 0; i++)
+ if (stack[i].index <= seqindex)
+ break;
+ else
+ stack.pop_back();
+
+ ASSERT(i >= 0);
+ snapshot_roll_back(stack[i].snapshotid);
+ return stack[i].index;
+}
+
+/** This method takes a snapshot at the given sequence number. */
+void SnapshotStack::snapshotStep(int seqindex)
+{
+ stack.push_back(snapshot_entry(take_snapshot(), seqindex));
+}
+
+void snapshot_stack_init()
+{
+ snap_stack = new SnapshotStack();
+ SnapshotGlobalSegments();
+}
+
+void snapshot_record(int seq_index)
+{
+ snap_stack->snapshotStep(seq_index);
+}
+
+int snapshot_backtrack_before(int seq_index)
+{
+ return snap_stack->backTrackBeforeStep(seq_index);
+}
--- /dev/null
+/**
+ * @file snapshot-interface.h
+ * @brief C interface layer on top of snapshotting system
+ */
+
+#ifndef __SNAPINTERFACE_H
+#define __SNAPINTERFACE_H
+
+typedef unsigned int snapshot_id;
+
+typedef void (*VoidFuncPtr)();
+void snapshot_system_init(unsigned int numbackingpages,
+ unsigned int numsnapshots, unsigned int nummemoryregions,
+ unsigned int numheappages, VoidFuncPtr entryPoint);
+
+void snapshot_stack_init();
+void snapshot_record(int seq_index);
+int snapshot_backtrack_before(int seq_index);
+
+#endif
--- /dev/null
+#include <inttypes.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/wait.h>
+
+#include "hashtable.h"
+#include "snapshot.h"
+#include "mymemory.h"
+#include "common.h"
+#include "context.h"
+
+/** PageAlignedAdressUpdate return a page aligned address for the
+ * address being added as a side effect the numBytes are also changed.
+ */
+static void * PageAlignAddressUpward(void *addr)
+{
+ return (void *)((((uintptr_t)addr) + PAGESIZE - 1) & ~(PAGESIZE - 1));
+}
+
+#if USE_MPROTECT_SNAPSHOT
+
+/* Each SnapShotRecord lists the firstbackingpage that must be written to
+ * revert to that snapshot */
+struct SnapShotRecord {
+ unsigned int firstBackingPage;
+};
+
+/** @brief Backing store page */
+typedef unsigned char snapshot_page_t[PAGESIZE];
+
+/* List the base address of the corresponding page in the backing store so we
+ * know where to copy it to */
+struct BackingPageRecord {
+ void *basePtrOfPage;
+};
+
+/* Struct for each memory region */
+struct MemoryRegion {
+ void *basePtr; // base of memory region
+ int sizeInPages; // size of memory region in pages
+};
+
+/** ReturnPageAlignedAddress returns a page aligned address for the
+ * address being added as a side effect the numBytes are also changed.
+ */
+static void * ReturnPageAlignedAddress(void *addr)
+{
+ return (void *)(((uintptr_t)addr) & ~(PAGESIZE - 1));
+}
+
+/* Primary struct for snapshotting system */
+struct mprot_snapshotter {
+ mprot_snapshotter(unsigned int numbackingpages, unsigned int numsnapshots, unsigned int nummemoryregions);
+ ~mprot_snapshotter();
+
+ struct MemoryRegion *regionsToSnapShot; //This pointer references an array of memory regions to snapshot
+ snapshot_page_t *backingStore; //This pointer references an array of snapshotpage's that form the backing store
+ void *backingStoreBasePtr; //This pointer references an array of snapshotpage's that form the backing store
+ struct BackingPageRecord *backingRecords; //This pointer references an array of backingpagerecord's (same number of elements as backingstore
+ struct SnapShotRecord *snapShots; //This pointer references the snapshot array
+
+ unsigned int lastSnapShot; //Stores the next snapshot record we should use
+ unsigned int lastBackingPage; //Stores the next backingpage we should use
+ unsigned int lastRegion; //Stores the next memory region to be used
+
+ unsigned int maxRegions; //Stores the max number of memory regions we support
+ unsigned int maxBackingPages; //Stores the total number of backing pages
+ unsigned int maxSnapShots; //Stores the total number of snapshots we allow
+
+ MEMALLOC
+};
+
+static struct mprot_snapshotter *mprot_snap = NULL;
+
+mprot_snapshotter::mprot_snapshotter(unsigned int backing_pages, unsigned int snapshots, unsigned int regions) :
+ lastSnapShot(0),
+ lastBackingPage(0),
+ lastRegion(0),
+ maxRegions(regions),
+ maxBackingPages(backing_pages),
+ maxSnapShots(snapshots)
+{
+ regionsToSnapShot = (struct MemoryRegion *)model_malloc(sizeof(struct MemoryRegion) * regions);
+ backingStoreBasePtr = (void *)model_malloc(sizeof(snapshot_page_t) * (backing_pages + 1));
+ //Page align the backingstorepages
+ backingStore = (snapshot_page_t *)PageAlignAddressUpward(backingStoreBasePtr);
+ backingRecords = (struct BackingPageRecord *)model_malloc(sizeof(struct BackingPageRecord) * backing_pages);
+ snapShots = (struct SnapShotRecord *)model_malloc(sizeof(struct SnapShotRecord) * snapshots);
+}
+
+mprot_snapshotter::~mprot_snapshotter()
+{
+ model_free(regionsToSnapShot);
+ model_free(backingStoreBasePtr);
+ model_free(backingRecords);
+ model_free(snapShots);
+}
+
+/** mprot_handle_pf is the page fault handler for mprotect based snapshotting
+ * algorithm.
+ */
+static void mprot_handle_pf(int sig, siginfo_t *si, void *unused)
+{
+ if (si->si_code == SEGV_MAPERR) {
+ model_print("Segmentation fault at %p\n", si->si_addr);
+ model_print("For debugging, place breakpoint at: %s:%d\n",
+ __FILE__, __LINE__);
+ // print_trace(); // Trace printing may cause dynamic memory allocation
+ exit(EXIT_FAILURE);
+ }
+ void* addr = ReturnPageAlignedAddress(si->si_addr);
+
+ unsigned int backingpage = mprot_snap->lastBackingPage++; //Could run out of pages...
+ if (backingpage == mprot_snap->maxBackingPages) {
+ model_print("Out of backing pages at %p\n", si->si_addr);
+ exit(EXIT_FAILURE);
+ }
+
+ //copy page
+ memcpy(&(mprot_snap->backingStore[backingpage]), addr, sizeof(snapshot_page_t));
+ //remember where to copy page back to
+ mprot_snap->backingRecords[backingpage].basePtrOfPage = addr;
+ //set protection to read/write
+ if (mprotect(addr, sizeof(snapshot_page_t), PROT_READ | PROT_WRITE)) {
+ perror("mprotect");
+ // Handle error by quitting?
+ }
+}
+
+static void mprot_snapshot_init(unsigned int numbackingpages,
+ unsigned int numsnapshots, unsigned int nummemoryregions,
+ unsigned int numheappages, VoidFuncPtr entryPoint)
+{
+ /* Setup a stack for our signal handler.... */
+ stack_t ss;
+ ss.ss_sp = PageAlignAddressUpward(model_malloc(SIGSTACKSIZE + PAGESIZE - 1));
+ ss.ss_size = SIGSTACKSIZE;
+ ss.ss_flags = 0;
+ sigaltstack(&ss, NULL);
+
+ struct sigaction sa;
+ sa.sa_flags = SA_SIGINFO | SA_NODEFER | SA_RESTART | SA_ONSTACK;
+ sigemptyset(&sa.sa_mask);
+ sa.sa_sigaction = mprot_handle_pf;
+#ifdef MAC
+ if (sigaction(SIGBUS, &sa, NULL) == -1) {
+ perror("sigaction(SIGBUS)");
+ exit(EXIT_FAILURE);
+ }
+#endif
+ if (sigaction(SIGSEGV, &sa, NULL) == -1) {
+ perror("sigaction(SIGSEGV)");
+ exit(EXIT_FAILURE);
+ }
+
+ mprot_snap = new mprot_snapshotter(numbackingpages, numsnapshots, nummemoryregions);
+
+ // EVIL HACK: We need to make sure that calls into the mprot_handle_pf method don't cause dynamic links
+ // The problem is that we end up protecting state in the dynamic linker...
+ // Solution is to call our signal handler before we start protecting stuff...
+
+ siginfo_t si;
+ memset(&si, 0, sizeof(si));
+ si.si_addr = ss.ss_sp;
+ mprot_handle_pf(SIGSEGV, &si, NULL);
+ mprot_snap->lastBackingPage--; //remove the fake page we copied
+
+ void *basemySpace = model_malloc((numheappages + 1) * PAGESIZE);
+ void *pagealignedbase = PageAlignAddressUpward(basemySpace);
+ user_snapshot_space = create_mspace_with_base(pagealignedbase, numheappages * PAGESIZE, 1);
+ snapshot_add_memory_region(pagealignedbase, numheappages);
+
+ void *base_model_snapshot_space = model_malloc((numheappages + 1) * PAGESIZE);
+ pagealignedbase = PageAlignAddressUpward(base_model_snapshot_space);
+ model_snapshot_space = create_mspace_with_base(pagealignedbase, numheappages * PAGESIZE, 1);
+ snapshot_add_memory_region(pagealignedbase, numheappages);
+
+ entryPoint();
+}
+
+static void mprot_add_to_snapshot(void *addr, unsigned int numPages)
+{
+ unsigned int memoryregion = mprot_snap->lastRegion++;
+ if (memoryregion == mprot_snap->maxRegions) {
+ model_print("Exceeded supported number of memory regions!\n");
+ exit(EXIT_FAILURE);
+ }
+
+ DEBUG("snapshot region %p-%p (%u page%s)\n",
+ addr, (char *)addr + numPages * PAGESIZE, numPages,
+ numPages > 1 ? "s" : "");
+ mprot_snap->regionsToSnapShot[memoryregion].basePtr = addr;
+ mprot_snap->regionsToSnapShot[memoryregion].sizeInPages = numPages;
+}
+
+static snapshot_id mprot_take_snapshot()
+{
+ for (unsigned int region = 0; region < mprot_snap->lastRegion; region++) {
+ if (mprotect(mprot_snap->regionsToSnapShot[region].basePtr, mprot_snap->regionsToSnapShot[region].sizeInPages * sizeof(snapshot_page_t), PROT_READ) == -1) {
+ perror("mprotect");
+ model_print("Failed to mprotect inside of takeSnapShot\n");
+ exit(EXIT_FAILURE);
+ }
+ }
+ unsigned int snapshot = mprot_snap->lastSnapShot++;
+ if (snapshot == mprot_snap->maxSnapShots) {
+ model_print("Out of snapshots\n");
+ exit(EXIT_FAILURE);
+ }
+ mprot_snap->snapShots[snapshot].firstBackingPage = mprot_snap->lastBackingPage;
+
+ return snapshot;
+}
+
+static void mprot_roll_back(snapshot_id theID)
+{
+#if USE_MPROTECT_SNAPSHOT == 2
+ if (mprot_snap->lastSnapShot == (theID + 1)) {
+ for (unsigned int page = mprot_snap->snapShots[theID].firstBackingPage; page < mprot_snap->lastBackingPage; page++) {
+ memcpy(mprot_snap->backingRecords[page].basePtrOfPage, &mprot_snap->backingStore[page], sizeof(snapshot_page_t));
+ }
+ return;
+ }
+#endif
+
+ HashTable< void *, bool, uintptr_t, 4, model_malloc, model_calloc, model_free> duplicateMap;
+ for (unsigned int region = 0; region < mprot_snap->lastRegion; region++) {
+ if (mprotect(mprot_snap->regionsToSnapShot[region].basePtr, mprot_snap->regionsToSnapShot[region].sizeInPages * sizeof(snapshot_page_t), PROT_READ | PROT_WRITE) == -1) {
+ perror("mprotect");
+ model_print("Failed to mprotect inside of takeSnapShot\n");
+ exit(EXIT_FAILURE);
+ }
+ }
+ for (unsigned int page = mprot_snap->snapShots[theID].firstBackingPage; page < mprot_snap->lastBackingPage; page++) {
+ if (!duplicateMap.contains(mprot_snap->backingRecords[page].basePtrOfPage)) {
+ duplicateMap.put(mprot_snap->backingRecords[page].basePtrOfPage, true);
+ memcpy(mprot_snap->backingRecords[page].basePtrOfPage, &mprot_snap->backingStore[page], sizeof(snapshot_page_t));
+ }
+ }
+ mprot_snap->lastSnapShot = theID;
+ mprot_snap->lastBackingPage = mprot_snap->snapShots[theID].firstBackingPage;
+ mprot_take_snapshot(); //Make sure current snapshot is still good...All later ones are cleared
+}
+
+#else /* !USE_MPROTECT_SNAPSHOT */
+
+#define SHARED_MEMORY_DEFAULT (100 * ((size_t)1 << 20)) // 100mb for the shared memory
+#define STACK_SIZE_DEFAULT (((size_t)1 << 20) * 20) // 20 mb out of the above 100 mb for my stack
+
+struct fork_snapshotter {
+ /** @brief Pointer to the shared (non-snapshot) memory heap base
+ * (NOTE: this has size SHARED_MEMORY_DEFAULT - sizeof(*fork_snap)) */
+ void *mSharedMemoryBase;
+
+ /** @brief Pointer to the shared (non-snapshot) stack region */
+ void *mStackBase;
+
+ /** @brief Size of the shared stack */
+ size_t mStackSize;
+
+ /**
+ * @brief Stores the ID that we are attempting to roll back to
+ *
+ * Used in inter-process communication so that each process can
+ * determine whether or not to take over execution (w/ matching ID) or
+ * exit (we're rolling back even further). Dubiously marked 'volatile'
+ * to prevent compiler optimizations from messing with the
+ * inter-process behavior.
+ */
+ volatile snapshot_id mIDToRollback;
+
+ /**
+ * @brief The context for the shared (non-snapshot) stack
+ *
+ * This context is passed between the various processes which represent
+ * various snapshot states. It should be used primarily for the
+ * "client-side" code, not the main snapshot loop.
+ */
+ ucontext_t shared_ctxt;
+
+ /** @brief Inter-process tracking of the next snapshot ID */
+ snapshot_id currSnapShotID;
+};
+
+static struct fork_snapshotter *fork_snap = NULL;
+
+/** @statics
+* These variables are necessary because the stack is shared region and
+* there exists a race between all processes executing the same function.
+* To avoid the problem above, we require variables allocated in 'safe' regions.
+* The bug was actually observed with the forkID, these variables below are
+* used to indicate the various contexts to which to switch to.
+*
+* @private_ctxt: the context which is internal to the current process. Used
+* for running the internal snapshot/rollback loop.
+* @exit_ctxt: a special context used just for exiting from a process (so we
+* can use swapcontext() instead of setcontext() + hacks)
+* @snapshotid: it is a running counter for the various forked processes
+* snapshotid. it is incremented and set in a persistently shared record
+*/
+static ucontext_t private_ctxt;
+static ucontext_t exit_ctxt;
+static snapshot_id snapshotid = 0;
+
+/**
+ * @brief Create a new context, with a given stack and entry function
+ * @param ctxt The context structure to fill
+ * @param stack The stack to run the new context in
+ * @param stacksize The size of the stack
+ * @param func The entry point function for the context
+ */
+static void create_context(ucontext_t *ctxt, void *stack, size_t stacksize,
+ void (*func)(void))
+{
+ getcontext(ctxt);
+ ctxt->uc_stack.ss_sp = stack;
+ ctxt->uc_stack.ss_size = stacksize;
+ makecontext(ctxt, func, 0);
+}
+
+/** @brief An empty function, used for an "empty" context which just exits a
+ * process */
+static void fork_exit()
+{
+ /* Intentionally empty */
+}
+
+static void createSharedMemory()
+{
+ //step 1. create shared memory.
+ void *memMapBase = mmap(0, SHARED_MEMORY_DEFAULT + STACK_SIZE_DEFAULT, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+ if (memMapBase == MAP_FAILED) {
+ perror("mmap");
+ exit(EXIT_FAILURE);
+ }
+
+ //Setup snapshot record at top of free region
+ fork_snap = (struct fork_snapshotter *)memMapBase;
+ fork_snap->mSharedMemoryBase = (void *)((uintptr_t)memMapBase + sizeof(*fork_snap));
+ fork_snap->mStackBase = (void *)((uintptr_t)memMapBase + SHARED_MEMORY_DEFAULT);
+ fork_snap->mStackSize = STACK_SIZE_DEFAULT;
+ fork_snap->mIDToRollback = -1;
+ fork_snap->currSnapShotID = 0;
+}
+
+/**
+ * Create a new mspace pointer for the non-snapshotting (i.e., inter-process
+ * shared) memory region. Only for fork-based snapshotting.
+ *
+ * @return The shared memory mspace
+ */
+mspace create_shared_mspace()
+{
+ if (!fork_snap)
+ createSharedMemory();
+ return create_mspace_with_base((void *)(fork_snap->mSharedMemoryBase), SHARED_MEMORY_DEFAULT - sizeof(*fork_snap), 1);
+}
+
+static void fork_snapshot_init(unsigned int numbackingpages,
+ unsigned int numsnapshots, unsigned int nummemoryregions,
+ unsigned int numheappages, VoidFuncPtr entryPoint)
+{
+ if (!fork_snap)
+ createSharedMemory();
+
+ void *base_model_snapshot_space = malloc((numheappages + 1) * PAGESIZE);
+ void *pagealignedbase = PageAlignAddressUpward(base_model_snapshot_space);
+ model_snapshot_space = create_mspace_with_base(pagealignedbase, numheappages * PAGESIZE, 1);
+
+ /* setup an "exiting" context */
+ char stack[128];
+ create_context(&exit_ctxt, stack, sizeof(stack), fork_exit);
+
+ /* setup the shared-stack context */
+ create_context(&fork_snap->shared_ctxt, fork_snap->mStackBase,
+ STACK_SIZE_DEFAULT, entryPoint);
+ /* switch to a new entryPoint context, on a new stack */
+ model_swapcontext(&private_ctxt, &fork_snap->shared_ctxt);
+
+ /* switch back here when takesnapshot is called */
+ snapshotid = fork_snap->currSnapShotID;
+
+ while (true) {
+ pid_t forkedID;
+ fork_snap->currSnapShotID = snapshotid + 1;
+ forkedID = fork();
+
+ if (0 == forkedID) {
+ setcontext(&fork_snap->shared_ctxt);
+ } else {
+ DEBUG("parent PID: %d, child PID: %d, snapshot ID: %d\n",
+ getpid(), forkedID, snapshotid);
+
+ while (waitpid(forkedID, NULL, 0) < 0) {
+ /* waitpid() may be interrupted */
+ if (errno != EINTR) {
+ perror("waitpid");
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ if (fork_snap->mIDToRollback != snapshotid)
+ exit(EXIT_SUCCESS);
+ }
+ }
+}
+
+static snapshot_id fork_take_snapshot()
+{
+ model_swapcontext(&fork_snap->shared_ctxt, &private_ctxt);
+ DEBUG("TAKESNAPSHOT RETURN\n");
+ return snapshotid;
+}
+
+static void fork_roll_back(snapshot_id theID)
+{
+ DEBUG("Rollback\n");
+ fork_snap->mIDToRollback = theID;
+ model_swapcontext(&fork_snap->shared_ctxt, &exit_ctxt);
+ fork_snap->mIDToRollback = -1;
+}
+
+#endif /* !USE_MPROTECT_SNAPSHOT */
+
+/**
+ * @brief Initializes the snapshot system
+ * @param entryPoint the function that should run the program.
+ */
+void snapshot_system_init(unsigned int numbackingpages,
+ unsigned int numsnapshots, unsigned int nummemoryregions,
+ unsigned int numheappages, VoidFuncPtr entryPoint)
+{
+#if USE_MPROTECT_SNAPSHOT
+ mprot_snapshot_init(numbackingpages, numsnapshots, nummemoryregions, numheappages, entryPoint);
+#else
+ fork_snapshot_init(numbackingpages, numsnapshots, nummemoryregions, numheappages, entryPoint);
+#endif
+}
+
+/** Assumes that addr is page aligned. */
+void snapshot_add_memory_region(void *addr, unsigned int numPages)
+{
+#if USE_MPROTECT_SNAPSHOT
+ mprot_add_to_snapshot(addr, numPages);
+#else
+ /* not needed for fork-based snapshotting */
+#endif
+}
+
+/** Takes a snapshot of memory.
+ * @return The snapshot identifier.
+ */
+snapshot_id take_snapshot()
+{
+#if USE_MPROTECT_SNAPSHOT
+ return mprot_take_snapshot();
+#else
+ return fork_take_snapshot();
+#endif
+}
+
+/** Rolls the memory state back to the given snapshot identifier.
+ * @param theID is the snapshot identifier to rollback to.
+ */
+void snapshot_roll_back(snapshot_id theID)
+{
+#if USE_MPROTECT_SNAPSHOT
+ mprot_roll_back(theID);
+#else
+ fork_roll_back(theID);
+#endif
+}
--- /dev/null
+/** @file snapshot.h
+ * @brief Snapshotting interface header file.
+ */
+
+#ifndef _SNAPSHOT_H
+#define _SNAPSHOT_H
+
+#include "snapshot-interface.h"
+#include "config.h"
+#include "mymemory.h"
+
+void snapshot_add_memory_region(void *ptr, unsigned int numPages);
+snapshot_id take_snapshot();
+void snapshot_roll_back(snapshot_id theSnapShot);
+
+#if !USE_MPROTECT_SNAPSHOT
+mspace create_shared_mspace();
+#endif
+
+#endif
--- /dev/null
+// stacktrace.h (c) 2008, Timo Bingmann from http://idlebox.net/
+// published under the WTFPL v2.0
+
+#ifndef __STACKTRACE_H__
+#define __STACKTRACE_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <execinfo.h>
+#include <cxxabi.h>
+
+/**
+ * @brief Print a demangled stack backtrace of the caller function to file
+ * descriptor fd.
+ */
+static inline void print_stacktrace(int fd = STDERR_FILENO, unsigned int max_frames = 63)
+{
+ dprintf(fd, "stack trace:\n");
+
+ // storage array for stack trace address data
+ void* addrlist[max_frames+1];
+
+ // retrieve current stack addresses
+ int addrlen = backtrace(addrlist, sizeof(addrlist) / sizeof(void*));
+
+ if (addrlen == 0) {
+ dprintf(fd, " <empty, possibly corrupt>\n");
+ return;
+ }
+
+ // resolve addresses into strings containing "filename(function+address)",
+ // this array must be free()-ed
+ char** symbollist = backtrace_symbols(addrlist, addrlen);
+
+ // allocate string which will be filled with the demangled function name
+ size_t funcnamesize = 256;
+ char* funcname = (char*)malloc(funcnamesize);
+
+ // iterate over the returned symbol lines. skip the first, it is the
+ // address of this function.
+ for (int i = 1; i < addrlen; i++) {
+ char *begin_name = 0, *begin_offset = 0, *end_offset = 0;
+
+ // find parentheses and +address offset surrounding the mangled name:
+ // ./module(function+0x15c) [0x8048a6d]
+ for (char *p = symbollist[i]; *p; ++p) {
+ if (*p == '(')
+ begin_name = p;
+ else if (*p == '+')
+ begin_offset = p;
+ else if (*p == ')' && begin_offset) {
+ end_offset = p;
+ break;
+ }
+ }
+
+ if (begin_name && begin_offset && end_offset && begin_name < begin_offset) {
+ *begin_name++ = '\0';
+ *begin_offset++ = '\0';
+ *end_offset = '\0';
+
+ // mangled name is now in [begin_name, begin_offset) and caller
+ // offset in [begin_offset, end_offset). now apply
+ // __cxa_demangle():
+
+ int status;
+ char* ret = abi::__cxa_demangle(begin_name,
+ funcname, &funcnamesize, &status);
+ if (status == 0) {
+ funcname = ret; // use possibly realloc()-ed string
+ dprintf(fd, " %s : %s+%s\n",
+ symbollist[i], funcname, begin_offset);
+ } else {
+ // demangling failed. Output function name as a C function with
+ // no arguments.
+ dprintf(fd, " %s : %s()+%s\n",
+ symbollist[i], begin_name, begin_offset);
+ }
+ } else {
+ // couldn't parse the line? print the whole line.
+ dprintf(fd, " %s\n", symbollist[i]);
+ }
+ }
+
+ free(funcname);
+ free(symbollist);
+}
+
+static inline void print_stacktrace(FILE *out, unsigned int max_frames = 63)
+{
+ print_stacktrace(fileno(out), max_frames);
+}
+
+#endif // __STACKTRACE_H__
--- /dev/null
+#ifndef __STL_MODEL_H__
+#define __STL_MODEL_H__
+
+#include <vector>
+#include <list>
+#include "mymemory.h"
+
+template<typename _Tp>
+class ModelList : public std::list<_Tp, ModelAlloc<_Tp> >
+{
+ public:
+ typedef std::list< _Tp, ModelAlloc<_Tp> > list;
+
+ ModelList() :
+ list()
+ { }
+
+ ModelList(size_t n, const _Tp& val = _Tp()) :
+ list(n, val)
+ { }
+
+ MEMALLOC
+};
+
+template<typename _Tp>
+class SnapList : public std::list<_Tp, SnapshotAlloc<_Tp> >
+{
+ public:
+ typedef std::list<_Tp, SnapshotAlloc<_Tp> > list;
+
+ SnapList() :
+ list()
+ { }
+
+ SnapList(size_t n, const _Tp& val = _Tp()) :
+ list(n, val)
+ { }
+
+ SNAPSHOTALLOC
+};
+
+template<typename _Tp>
+class ModelVector : public std::vector<_Tp, ModelAlloc<_Tp> >
+{
+ public:
+ typedef std::vector< _Tp, ModelAlloc<_Tp> > vector;
+
+ ModelVector() :
+ vector()
+ { }
+
+ ModelVector(size_t n, const _Tp& val = _Tp()) :
+ vector(n, val)
+ { }
+
+ MEMALLOC
+};
+
+template<typename _Tp>
+class SnapVector : public std::vector<_Tp, SnapshotAlloc<_Tp> >
+{
+ public:
+ typedef std::vector< _Tp, SnapshotAlloc<_Tp> > vector;
+
+ SnapVector() :
+ vector()
+ { }
+
+ SnapVector(size_t n, const _Tp& val = _Tp()) :
+ vector(n, val)
+ { }
+
+ SNAPSHOTALLOC
+};
+
+#endif /* __STL_MODEL_H__ */
--- /dev/null
+BASE := ..
+
+OBJECTS := $(patsubst %.c, %.o, $(wildcard *.c))
+OBJECTS += $(patsubst %.cc, %.o, $(wildcard *.cc))
+
+include $(BASE)/common.mk
+
+DIR := litmus
+include $(DIR)/Makefile
+
+DEPS := $(join $(addsuffix ., $(dir $(OBJECTS))), $(addsuffix .d, $(notdir $(OBJECTS))))
+
+CPPFLAGS += -I$(BASE) -I$(BASE)/include
+
+all: $(OBJECTS)
+
+-include $(DEPS)
+
+%.o: %.c
+ $(CC) -MMD -MF $(@D)/.$(@F).d -o $@ $< $(CPPFLAGS) -L$(BASE) -l$(LIB_NAME)
+
+%.o: %.cc
+ $(CXX) -MMD -MF $(@D)/.$(@F).d -o $@ $< $(CPPFLAGS) -L$(BASE) -l$(LIB_NAME)
+
+clean::
+ rm -f $(OBJECTS) $(DEPS)
--- /dev/null
+/**
+ * @file addr-satcycle.cc
+ * @brief Address-based satisfaction cycle test
+ *
+ * This program has a peculiar behavior which is technically legal under the
+ * current C++ memory model but which is a result of a type of satisfaction
+ * cycle. We use this as justification for part of our modifications to the
+ * memory model when proving our model-checker's correctness.
+ */
+
+#include <atomic>
+#include <threads.h>
+#include <stdio.h>
+
+#include "model-assert.h"
+
+using namespace std;
+
+atomic_int x[2], idx, y;
+
+int r1, r2, r3; /* "local" variables */
+
+static void a(void *obj)
+{
+ r1 = idx.load(memory_order_relaxed);
+ x[r1].store(0, memory_order_relaxed);
+
+ /* Key point: can we guarantee that &x[0] == &x[r1]? */
+ r2 = x[0].load(memory_order_relaxed);
+ y.store(r2);
+}
+
+static void b(void *obj)
+{
+ r3 = y.load(memory_order_relaxed);
+ idx.store(r3, memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ atomic_init(&x[0], 1);
+ atomic_init(&idx, 0);
+ atomic_init(&y, 0);
+
+ printf("Main thread: creating 2 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ printf("Main thread is finished\n");
+
+ printf("r1 = %d\n", r1);
+ printf("r2 = %d\n", r2);
+ printf("r3 = %d\n", r3);
+
+ /*
+ * This condition should not be hit because it only occurs under a
+ * satisfaction cycle
+ */
+ bool cycle = (r1 == 1 && r2 == 1 && r3 == 1);
+ MODEL_ASSERT(!cycle);
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+
+#include "threads.h"
+#include "librace.h"
+#include "stdatomic.h"
+#include <mutex>
+#include <condition_variable>
+
+std::mutex * m;
+std::condition_variable *v;
+int shareddata;
+
+static void a(void *obj)
+{
+
+ m->lock();
+ while(load_32(&shareddata)==0)
+ v->wait(*m);
+ m->unlock();
+
+}
+
+static void b(void *obj)
+{
+ m->lock();
+ store_32(&shareddata, (unsigned int) 1);
+ v->notify_all();
+ m->unlock();
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+ store_32(&shareddata, (unsigned int) 0);
+ m=new std::mutex();
+ v=new std::condition_variable();
+
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+
+atomic_int a;
+atomic_int b;
+
+static void r(void *obj)
+{
+ int r1=atomic_load_explicit(&a, memory_order_relaxed);
+ int r2=atomic_load_explicit(&a, memory_order_relaxed);
+ if (r1==r2)
+ atomic_store_explicit(&b, 2, memory_order_relaxed);
+ printf("r1=%d\n",r1);
+ printf("r2=%d\n",r2);
+}
+
+static void s(void *obj)
+{
+ int r3=atomic_load_explicit(&b, memory_order_relaxed);
+ atomic_store_explicit(&a, r3, memory_order_relaxed);
+ printf("r3=%d\n",r3);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ atomic_init(&a, 0);
+ atomic_init(&b, 1);
+
+ printf("Main thread: creating 2 threads\n");
+ thrd_create(&t1, (thrd_start_t)&r, NULL);
+ thrd_create(&t2, (thrd_start_t)&s, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <mutex>
+
+#include "librace.h"
+
+std::mutex *x;
+std::mutex *y;
+uint32_t shared = 0;
+
+static void a(void *obj)
+{
+ x->lock();
+ y->lock();
+ printf("shared = %u\n", load_32(&shared));
+ y->unlock();
+ x->unlock();
+}
+
+static void b(void *obj)
+{
+ y->lock();
+ x->lock();
+ store_32(&shared, 16);
+ printf("write shared = 16\n");
+ x->unlock();
+ y->unlock();
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ x = new std::mutex();
+ y = new std::mutex();
+
+ printf("Main thread: creating 2 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+/*
+ * Try to read the same value as a future value twice.
+ *
+ * This test should be able to see r1 = r2 = 42. Currently, we never see that
+ * (as of 2/21/13) because the r2 load won't have a potential future value of
+ * 42 at the same time as r1, due to our scheduling (the loads for r1 and r2
+ * must occur before the write of x = 42).
+ *
+ * Note that the atomic_int y is simply used to aid in forcing a particularly
+ * interesting scheduling. It is superfluous.
+ */
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+
+atomic_int x;
+atomic_int y;
+
+static void a(void *obj)
+{
+ int r1 = atomic_load_explicit(&x, memory_order_relaxed);
+ int r2 = atomic_load_explicit(&x, memory_order_relaxed);
+ printf("r1 = %d, r2 = %d\n", r1, r2);
+}
+
+static void b(void *obj)
+{
+ atomic_store_explicit(&y, 43, memory_order_relaxed);
+ atomic_store_explicit(&x, 42, memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+
+ printf("Main thread: creating 2 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+/*
+ * This test performs some relaxed, release, acquire opeations on a single
+ * atomic variable. It can give some rough idea of release sequence support but
+ * probably should be improved to give better information.
+ *
+ * This test tries to establish two release sequences, where we should always
+ * either establish both or establish neither. (Note that this is only true for
+ * a few executions of interest, where both load-acquire's read from the same
+ * write.)
+ */
+
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+
+atomic_int x;
+int var = 0;
+
+static void a(void *obj)
+{
+ store_32(&var, 1);
+ atomic_store_explicit(&x, 1, memory_order_release);
+ atomic_store_explicit(&x, 42, memory_order_relaxed);
+}
+
+static void b(void *obj)
+{
+ int r = atomic_load_explicit(&x, memory_order_acquire);
+ printf("r = %d\n", r);
+ printf("load %d\n", load_32(&var));
+}
+
+static void c(void *obj)
+{
+ atomic_store_explicit(&x, 2, memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2, t3, t4;
+
+ atomic_init(&x, 0);
+
+ printf("Main thread: creating 4 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+ thrd_create(&t3, (thrd_start_t)&b, NULL);
+ thrd_create(&t4, (thrd_start_t)&c, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ thrd_join(t3);
+ thrd_join(t4);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+
+atomic_int x;
+atomic_int y;
+
+static void a(void *obj)
+{
+ atomic_store_explicit(&x, 1, memory_order_relaxed);
+ atomic_store_explicit(&x, 2, memory_order_relaxed);
+ atomic_thread_fence(memory_order_seq_cst);
+ printf("Thread A reads: %d\n", atomic_load_explicit(&y, memory_order_relaxed));
+}
+
+static void b(void *obj)
+{
+ atomic_store_explicit(&y, 1, memory_order_relaxed);
+ atomic_store_explicit(&y, 2, memory_order_relaxed);
+ atomic_thread_fence(memory_order_seq_cst);
+ printf("Thread B reads: %d\n", atomic_load_explicit(&x, memory_order_relaxed));
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+
+ printf("Main thread: creating 2 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ printf("Main thread is finishing\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+#include "model-assert.h"
+
+atomic_int x;
+atomic_int y;
+
+static void a(void *obj)
+{
+ atomic_store_explicit(&x, 1, memory_order_relaxed);
+ atomic_thread_fence(memory_order_release);
+ atomic_store_explicit(&x, 2, memory_order_relaxed);
+}
+
+static void b(void *obj)
+{
+ int r1, r2;
+ r1 = atomic_load_explicit(&x, memory_order_relaxed);
+ atomic_thread_fence(memory_order_acquire);
+ r2 = atomic_load_explicit(&x, memory_order_relaxed);
+
+ printf("FENCES: r1 = %d, r2 = %d\n", r1, r2);
+ if (r1 == 2)
+ MODEL_ASSERT(r2 != 1);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+
+ printf("Main thread: creating 2 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ printf("Main thread is finishing\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdlib.h>
+#include <stdio.h>
+#include <threads.h>
+#include <atomic>
+
+#include "librace.h"
+#include "model-assert.h"
+
+using namespace std;
+
+atomic_int x, y;
+atomic_intptr_t z, z2;
+
+int r1, r2, r3; /* "local" variables */
+
+/**
+ This example illustrates a self-satisfying cycle involving
+ synchronization. A failed synchronization creates the store that
+ causes the synchronization to fail.
+
+ The C++11 memory model nominally allows r1=0, r2=1, r3=5.
+
+ This example is insane, we don't support that behavior.
+*/
+
+
+static void a(void *obj)
+{
+ z.store((intptr_t)&y, memory_order_relaxed);
+ r1 = y.fetch_add(1, memory_order_release);
+ z.store((intptr_t)&x, memory_order_relaxed);
+ r2 = y.fetch_add(1, memory_order_release);
+}
+
+
+static void b(void *obj)
+{
+ r3 = y.fetch_add(1, memory_order_acquire);
+ intptr_t ptr = z.load(memory_order_relaxed);
+ z2.store(ptr, memory_order_relaxed);
+}
+
+static void c(void *obj)
+{
+ atomic_int *ptr2 = (atomic_int *)z2.load(memory_order_relaxed);
+ (*ptr2).store(5, memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2, t3;
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+ atomic_init(&z, (intptr_t) &x);
+ atomic_init(&z2, (intptr_t) &x);
+
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+ thrd_create(&t3, (thrd_start_t)&c, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ thrd_join(t3);
+
+ printf("r1=%d, r2=%d, r3=%d\n", r1, r2, r3);
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+
+#define RW_LOCK_BIAS 0x00100000
+#define WRITE_LOCK_CMP RW_LOCK_BIAS
+
+/** Example implementation of linux rw lock along with 2 thread test
+ * driver... */
+
+typedef union {
+ atomic_int lock;
+} rwlock_t;
+
+static inline int read_can_lock(rwlock_t *lock)
+{
+ return atomic_load_explicit(&lock->lock, memory_order_relaxed) > 0;
+}
+
+static inline int write_can_lock(rwlock_t *lock)
+{
+ return atomic_load_explicit(&lock->lock, memory_order_relaxed) == RW_LOCK_BIAS;
+}
+
+static inline void read_lock(rwlock_t *rw)
+{
+ int priorvalue = atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
+ while (priorvalue <= 0) {
+ atomic_fetch_add_explicit(&rw->lock, 1, memory_order_relaxed);
+ do {
+ priorvalue = atomic_load_explicit(&rw->lock, memory_order_relaxed);
+ } while (priorvalue <= 0);
+ priorvalue = atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
+ }
+}
+
+static inline void write_lock(rwlock_t *rw)
+{
+ int priorvalue = atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
+ while (priorvalue != RW_LOCK_BIAS) {
+ atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_relaxed);
+ do {
+ priorvalue = atomic_load_explicit(&rw->lock, memory_order_relaxed);
+ } while (priorvalue != RW_LOCK_BIAS);
+ priorvalue = atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
+ }
+}
+
+static inline int read_trylock(rwlock_t *rw)
+{
+ int priorvalue = atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
+ if (priorvalue > 0)
+ return 1;
+
+ atomic_fetch_add_explicit(&rw->lock, 1, memory_order_relaxed);
+ return 0;
+}
+
+static inline int write_trylock(rwlock_t *rw)
+{
+ int priorvalue = atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
+ if (priorvalue == RW_LOCK_BIAS)
+ return 1;
+
+ atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_relaxed);
+ return 0;
+}
+
+static inline void read_unlock(rwlock_t *rw)
+{
+ atomic_fetch_add_explicit(&rw->lock, 1, memory_order_release);
+}
+
+static inline void write_unlock(rwlock_t *rw)
+{
+ atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_release);
+}
+
+rwlock_t mylock;
+int shareddata;
+
+static void a(void *obj)
+{
+ int i;
+ for(i = 0; i < 2; i++) {
+ if ((i % 2) == 0) {
+ read_lock(&mylock);
+ load_32(&shareddata);
+ read_unlock(&mylock);
+ } else {
+ write_lock(&mylock);
+ store_32(&shareddata,(unsigned int)i);
+ write_unlock(&mylock);
+ }
+ }
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+ atomic_init(&mylock.lock, RW_LOCK_BIAS);
+
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&a, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+
+#define RW_LOCK_BIAS 0x00100000
+#define WRITE_LOCK_CMP RW_LOCK_BIAS
+
+/** Example implementation of linux rw lock along with 2 thread test
+ * driver... */
+
+typedef union {
+ atomic_int lock;
+} rwlock_t;
+
+static inline int read_can_lock(rwlock_t *lock)
+{
+ return atomic_load_explicit(&lock->lock, memory_order_relaxed) > 0;
+}
+
+static inline int write_can_lock(rwlock_t *lock)
+{
+ return atomic_load_explicit(&lock->lock, memory_order_relaxed) == RW_LOCK_BIAS;
+}
+
+static inline void read_lock(rwlock_t *rw)
+{
+ int priorvalue = atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
+ while (priorvalue <= 0) {
+ atomic_fetch_add_explicit(&rw->lock, 1, memory_order_relaxed);
+ while (atomic_load_explicit(&rw->lock, memory_order_relaxed) <= 0) {
+ thrd_yield();
+ }
+ priorvalue = atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
+ }
+}
+
+static inline void write_lock(rwlock_t *rw)
+{
+ int priorvalue = atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
+ while (priorvalue != RW_LOCK_BIAS) {
+ atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_relaxed);
+ while (atomic_load_explicit(&rw->lock, memory_order_relaxed) != RW_LOCK_BIAS) {
+ thrd_yield();
+ }
+ priorvalue = atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
+ }
+}
+
+static inline int read_trylock(rwlock_t *rw)
+{
+ int priorvalue = atomic_fetch_sub_explicit(&rw->lock, 1, memory_order_acquire);
+ if (priorvalue > 0)
+ return 1;
+
+ atomic_fetch_add_explicit(&rw->lock, 1, memory_order_relaxed);
+ return 0;
+}
+
+static inline int write_trylock(rwlock_t *rw)
+{
+ int priorvalue = atomic_fetch_sub_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_acquire);
+ if (priorvalue == RW_LOCK_BIAS)
+ return 1;
+
+ atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_relaxed);
+ return 0;
+}
+
+static inline void read_unlock(rwlock_t *rw)
+{
+ atomic_fetch_add_explicit(&rw->lock, 1, memory_order_release);
+}
+
+static inline void write_unlock(rwlock_t *rw)
+{
+ atomic_fetch_add_explicit(&rw->lock, RW_LOCK_BIAS, memory_order_release);
+}
+
+rwlock_t mylock;
+int shareddata;
+
+static void a(void *obj)
+{
+ int i;
+ for(i = 0; i < 2; i++) {
+ if ((i % 2) == 0) {
+ read_lock(&mylock);
+ load_32(&shareddata);
+ read_unlock(&mylock);
+ } else {
+ write_lock(&mylock);
+ store_32(&shareddata,(unsigned int)i);
+ write_unlock(&mylock);
+ }
+ }
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+ atomic_init(&mylock.lock, RW_LOCK_BIAS);
+
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&a, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+
+ return 0;
+}
--- /dev/null
+D := $(DIR)
+
+OBJECTS += $(patsubst %.c, %.o, $(wildcard $(D)/*.c))
+OBJECTS += $(patsubst %.cc, %.o, $(wildcard $(D)/*.cc))
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <atomic>
+
+std::atomic_int x;
+std::atomic_int y;
+
+std::memory_order store_mo = std::memory_order_release;
+std::memory_order load_mo = std::memory_order_acquire;
+
+static void a(void *obj)
+{
+ x.store(1, store_mo);
+}
+
+static void b(void *obj)
+{
+ y.store(1, store_mo);
+}
+
+static void c(void *obj)
+{
+ printf("x1: %d\n", x.load(load_mo));
+ printf("y1: %d\n", y.load(load_mo));
+}
+
+static void d(void *obj)
+{
+ printf("y2: %d\n", y.load(load_mo));
+ printf("x2: %d\n", x.load(load_mo));
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2, t3, t4;
+
+ /* Command-line argument 's' enables seq_cst test */
+ if (argc > 1 && *argv[1] == 's')
+ store_mo = load_mo = std::memory_order_seq_cst;
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+
+ printf("Main thread: creating 4 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+ thrd_create(&t3, (thrd_start_t)&c, NULL);
+ thrd_create(&t4, (thrd_start_t)&d, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ thrd_join(t3);
+ thrd_join(t4);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <atomic>
+
+std::atomic_int x;
+std::atomic_int y;
+
+static void a(void *obj)
+{
+ printf("x: %d\n", x.load(std::memory_order_relaxed));
+ y.store(1, std::memory_order_relaxed);
+}
+
+static void b(void *obj)
+{
+ printf("y: %d\n", y.load(std::memory_order_relaxed));
+ x.store(1, std::memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+
+ printf("Main thread: creating 2 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <atomic>
+
+std::atomic_int x;
+std::atomic_int y;
+
+static void a(void *obj)
+{
+ x.store(1, std::memory_order_relaxed);
+ y.store(1, std::memory_order_relaxed);
+}
+
+static void b(void *obj)
+{
+ printf("y1: %d\n", y.load(std::memory_order_relaxed));
+ printf("x1: %d\n", x.load(std::memory_order_relaxed));
+}
+
+static void c(void *obj)
+{
+ printf("x2: %d\n", x.load(std::memory_order_relaxed));
+ printf("y2: %d\n", y.load(std::memory_order_relaxed));
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2, t3;
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+
+ printf("Main thread: creating 3 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+ thrd_create(&t3, (thrd_start_t)&c, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ thrd_join(t3);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdlib.h>
+#include <stdio.h>
+#include <threads.h>
+#include <atomic>
+
+#include "model-assert.h"
+
+/*
+ * This 'seqlock' example should never trigger the MODEL_ASSERT() for
+ * release/acquire; it may trigger the MODEL_ASSERT() for release/consume
+ */
+
+std::atomic_int x;
+std::atomic_int y;
+std::atomic_int z;
+
+static int N = 1;
+
+static void a(void *obj)
+{
+ for (int i = 0; i < N; i++) {
+ x.store(2 * i + 1, std::memory_order_release);
+ y.store(i + 1, std::memory_order_release);
+ z.store(i + 1, std::memory_order_release);
+ x.store(2 * i + 2, std::memory_order_release);
+ }
+}
+
+static void b(void *obj)
+{
+ int x1, y1, z1, x2;
+ x1 = x.load(std::memory_order_acquire);
+ y1 = y.load(std::memory_order_acquire);
+ z1 = z.load(std::memory_order_acquire);
+ x2 = x.load(std::memory_order_acquire);
+ printf("x: %d\n", x1);
+ printf("y: %d\n", y1);
+ printf("z: %d\n", z1);
+ printf("x: %d\n", x2);
+
+ /* If x1 and x2 are the same, even value, then y1 must equal z1 */
+ MODEL_ASSERT(x1 != x2 || x1 & 0x1 || y1 == z1);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ if (argc > 1)
+ N = atoi(argv[1]);
+
+ printf("N: %d\n", N);
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+ atomic_init(&z, 0);
+
+ printf("Main thread: creating 2 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <atomic>
+
+std::atomic_int x;
+std::atomic_int y;
+
+static void a(void *obj)
+{
+ x.store(1, std::memory_order_relaxed);
+ printf("y: %d\n", y.load(std::memory_order_relaxed));
+}
+
+static void b(void *obj)
+{
+ y.store(1, std::memory_order_relaxed);
+ printf("x: %d\n", x.load(std::memory_order_relaxed));
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+
+ printf("Main thread: creating 2 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdlib.h>
+#include <stdio.h>
+#include <threads.h>
+#include <atomic>
+
+static int N = 2;
+
+/* Can be tested for different behavior with relaxed vs. release/acquire/seq-cst */
+#define load_mo std::memory_order_relaxed
+#define store_mo std::memory_order_relaxed
+
+static std::atomic_int *x;
+
+static void a(void *obj)
+{
+ int idx = *((int *)obj);
+
+ if (idx > 0)
+ x[idx - 1].load(load_mo);
+
+ if (idx < N)
+ x[idx].store(1, store_mo);
+ else
+ x[0].load(load_mo);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t *threads;
+ int *indexes;
+
+ if (argc > 1)
+ N = atoi(argv[1]);
+ if (N < 2) {
+ printf("Error: must have N >= 2\n");
+ return 1;
+ }
+ printf("N: %d\n", N);
+
+ threads = (thrd_t *)malloc((N + 1) * sizeof(thrd_t));
+ x = (std::atomic_int *)malloc(N * sizeof(std::atomic_int));
+ indexes = (int *)malloc((N + 1) * sizeof(int));
+
+ for (int i = 0; i < N + 1; i++)
+ indexes[i] = i;
+
+ for (int i = 0; i < N; i++)
+ atomic_init(&x[i], 0);
+
+ for (int i = 0; i < N + 1; i++)
+ thrd_create(&threads[i], (thrd_start_t)&a, (void *)&indexes[i]);
+
+ for (int i = 0; i < N + 1; i++)
+ thrd_join(threads[i]);
+
+ return 0;
+}
--- /dev/null
+/**
+ * @file mo-satcycle.cc
+ * @brief MO satisfaction cycle test
+ *
+ * This program has a peculiar behavior which is technically legal under the
+ * current C++ memory model but which is a result of a type of satisfaction
+ * cycle. We use this as justification for part of our modifications to the
+ * memory model when proving our model-checker's correctness.
+ */
+
+#include <atomic>
+#include <threads.h>
+#include <stdio.h>
+
+#include "model-assert.h"
+
+using namespace std;
+
+atomic_int x, y;
+int r0, r1, r2, r3; /* "local" variables */
+
+static void a(void *obj)
+{
+ y.store(10, memory_order_relaxed);
+ x.store(1, memory_order_release);
+}
+
+static void b(void *obj)
+{
+ r0 = x.load(memory_order_relaxed);
+ r1 = x.load(memory_order_acquire);
+ y.store(11, memory_order_relaxed);
+}
+
+static void c(void *obj)
+{
+ r2 = y.load(memory_order_relaxed);
+ r3 = y.load(memory_order_relaxed);
+ if (r2 == 11 && r3 == 10)
+ x.store(0, memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2, t3;
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+
+ printf("Main thread: creating 3 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+ thrd_create(&t3, (thrd_start_t)&c, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ thrd_join(t3);
+ printf("Main thread is finished\n");
+
+ /*
+ * This condition should not be hit because it only occurs under a
+ * satisfaction cycle
+ */
+ bool cycle = (r0 == 1 && r1 == 0 && r2 == 11 && r3 == 10);
+ MODEL_ASSERT(!cycle);
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+
+#include "threads.h"
+#include "librace.h"
+#include "stdatomic.h"
+#include <mutex>
+std::mutex * m;
+int shareddata;
+
+static void a(void *obj)
+{
+ int i;
+ for(i=0;i<2;i++) {
+ if ((i%2)==0) {
+ m->lock();
+ store_32(&shareddata,(unsigned int)i);
+ m->unlock();
+ } else {
+ while(!m->try_lock())
+ thrd_yield();
+ store_32(&shareddata,(unsigned int)i);
+ m->unlock();
+ }
+ }
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+ m=new std::mutex();
+
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&a, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ return 0;
+}
--- /dev/null
+#include <stdlib.h>
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+#include "model-assert.h"
+
+atomic_int x;
+atomic_int y;
+atomic_int z;
+static void a(void *obj)
+{
+ (void)atomic_load_explicit(&z, memory_order_relaxed); // this is only for schedule control
+ int t1=atomic_load_explicit(&x, memory_order_relaxed);
+ atomic_store_explicit(&y, 1, memory_order_relaxed);
+ printf("t1=%d\n",t1);
+}
+
+static void b(void *obj)
+{
+ int t2=atomic_load_explicit(&y, memory_order_relaxed);
+ atomic_store_explicit(&x, t2, memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+ atomic_init(&z, 0);
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+
+
+ return 0;
+}
--- /dev/null
+/*
+ * This test performs some relaxes, release, acquire opeations on a single
+ * atomic variable. It is designed for creating a difficult set of pending
+ * release sequences to resolve at the end of an execution. However, it
+ * utilizes 6 threads, so it blows up into a lot of executions quickly.
+ */
+
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+
+atomic_int x;
+int var = 0;
+
+static void a(void *obj)
+{
+ store_32(&var, 1);
+ atomic_store_explicit(&x, *((int *)obj), memory_order_release);
+ atomic_store_explicit(&x, *((int *)obj) + 1, memory_order_relaxed);
+}
+
+static void b2(void *obj)
+{
+ int r = atomic_load_explicit(&x, memory_order_acquire);
+ printf("r = %d\n", r);
+ store_32(&var, 3);
+}
+
+static void b1(void *obj)
+{
+ thrd_t t3, t4;
+ int i = 7;
+ int r = atomic_load_explicit(&x, memory_order_acquire);
+ printf("r = %d\n", r);
+ store_32(&var, 2);
+ thrd_create(&t3, (thrd_start_t)&a, &i);
+ thrd_create(&t4, (thrd_start_t)&b2, NULL);
+ thrd_join(t3);
+ thrd_join(t4);
+}
+
+static void c(void *obj)
+{
+ atomic_store_explicit(&x, 22, memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2, t5;
+ int i = 4;
+
+ atomic_init(&x, 0);
+
+ thrd_create(&t1, (thrd_start_t)&a, &i);
+ thrd_create(&t2, (thrd_start_t)&b1, NULL);
+ thrd_create(&t5, (thrd_start_t)&c, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ thrd_join(t5);
+
+ return 0;
+}
--- /dev/null
+/*
+ * This test performs some relaxes, release, acquire opeations on a single
+ * atomic variable. It can give some rough idea of release sequence support but
+ * probably should be improved to give better information.
+ */
+
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+
+atomic_int x;
+int var = 0;
+
+static void a(void *obj)
+{
+ store_32(&var, 1);
+ atomic_store_explicit(&x, 1, memory_order_release);
+ atomic_store_explicit(&x, 42, memory_order_relaxed);
+}
+
+static void b(void *obj)
+{
+ int r = atomic_load_explicit(&x, memory_order_acquire);
+ printf("r = %d\n", r);
+ printf("load %d\n", load_32(&var));
+}
+
+static void c(void *obj)
+{
+ atomic_store_explicit(&x, 2, memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2, t3;
+
+ atomic_init(&x, 0);
+
+ printf("Main thread: creating 3 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+ thrd_create(&t3, (thrd_start_t)&c, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ thrd_join(t3);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+
+atomic_int x;
+atomic_int y;
+
+static void a(void *obj)
+{
+ int v1=atomic_fetch_add_explicit(&x, 1, memory_order_relaxed);
+ int v2=atomic_fetch_add_explicit(&y, 1, memory_order_relaxed);
+ printf("v1 = %d, v2=%d\n", v1, v2);
+}
+
+static void b(void *obj)
+{
+ int v3=atomic_fetch_add_explicit(&y, 1, memory_order_relaxed);
+ int v4=atomic_fetch_add_explicit(&x, 1, memory_order_relaxed);
+ printf("v3 = %d, v4=%d\n", v3, v4);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+
+ return 0;
+}
--- /dev/null
+#include <stdlib.h>
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+#include "model-assert.h"
+
+atomic_int x;
+static int N = 2;
+
+static void a(void *obj)
+{
+ int i;
+ for (i = 0; i < N; i++)
+ atomic_fetch_add_explicit(&x, 1, memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ if (argc > 1)
+ N = atoi(argv[1]);
+
+ atomic_init(&x, 0);
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&a, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+
+ MODEL_ASSERT(atomic_load(&x) == N * 2);
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+
+atomic_int x;
+atomic_int y;
+atomic_int z;
+
+static int r1, r2, r3;
+
+static void a(void *obj)
+{
+ atomic_store_explicit(&z, 1, memory_order_relaxed);
+}
+
+static void b(void *obj)
+{
+ atomic_store_explicit(&x, 1, memory_order_relaxed);
+ atomic_store_explicit(&y, 1, memory_order_relaxed);
+ r1=atomic_load_explicit(&z, memory_order_relaxed);
+}
+static void c(void *obj)
+{
+ atomic_store_explicit(&z, 2, memory_order_relaxed);
+ atomic_store_explicit(&x, 2, memory_order_relaxed);
+ r2=atomic_load_explicit(&y, memory_order_relaxed);
+}
+
+static void d(void *obj)
+{
+ atomic_store_explicit(&z, 3, memory_order_relaxed);
+ atomic_store_explicit(&y, 2, memory_order_relaxed);
+ r3=atomic_load_explicit(&x, memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2,t3, t4;
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+ atomic_init(&z, 0);
+
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+ thrd_create(&t3, (thrd_start_t)&c, NULL);
+ thrd_create(&t4, (thrd_start_t)&d, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ thrd_join(t3);
+ thrd_join(t4);
+
+ /* Check and/or print r1, r2, r3? */
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+
+atomic_int x;
+atomic_int y;
+
+static void a(void *obj)
+{
+ int r1=atomic_load_explicit(&x, memory_order_relaxed);
+ atomic_store_explicit(&y, r1, memory_order_relaxed);
+ printf("r1=%d\n",r1);
+}
+
+static void b(void *obj)
+{
+ int r2=atomic_load_explicit(&y, memory_order_relaxed);
+ atomic_store_explicit(&x, r2, memory_order_relaxed);
+ atomic_store_explicit(&x, r2 + 1, memory_order_relaxed);
+ printf("r2=%d\n",r2);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ atomic_init(&x, -1);
+ atomic_init(&y, 0);
+
+ printf("Main thread: creating 2 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+/**
+ * @file uninit.cc
+ * @brief Uninitialized loads test
+ *
+ * This is a test of the "uninitialized loads" code. While we don't explicitly
+ * initialize y, this example's synchronization pattern should guarantee we
+ * never see it uninitialized.
+ */
+#include <stdio.h>
+#include <threads.h>
+#include <atomic>
+
+#include "librace.h"
+
+std::atomic_int x;
+std::atomic_int y;
+
+static void a(void *obj)
+{
+ int flag = x.load(std::memory_order_acquire);
+ printf("flag: %d\n", flag);
+ if (flag == 2)
+ printf("Load: %d\n", y.load(std::memory_order_relaxed));
+}
+
+static void b(void *obj)
+{
+ printf("fetch_add: %d\n", x.fetch_add(1, std::memory_order_relaxed));
+}
+
+static void c(void *obj)
+{
+ y.store(3, std::memory_order_relaxed);
+ x.store(1, std::memory_order_release);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2, t3;
+
+ std::atomic_init(&x, 0);
+
+ printf("Main thread: creating 3 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+ thrd_create(&t3, (thrd_start_t)&c, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ thrd_join(t3);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+
+#include "librace.h"
+
+atomic_int x;
+atomic_int y;
+
+static void a(void *obj)
+{
+ int r1=atomic_load_explicit(&y, memory_order_relaxed);
+ atomic_store_explicit(&x, r1, memory_order_relaxed);
+ printf("r1=%d\n",r1);
+}
+
+static void b(void *obj)
+{
+ int r2=atomic_load_explicit(&x, memory_order_relaxed);
+ atomic_store_explicit(&y, 42, memory_order_relaxed);
+ printf("r2=%d\n",r2);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2;
+
+ atomic_init(&x, 0);
+ atomic_init(&y, 0);
+
+ printf("Main thread: creating 2 threads\n");
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ printf("Main thread is finished\n");
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+#include "librace.h"
+ atomic_int x1;
+ atomic_int x2;
+ atomic_int x3;
+ atomic_int x4;
+ atomic_int x5;
+ atomic_int x6;
+ atomic_int x7;
+static void a(void *obj)
+{
+ atomic_store_explicit(&x1, 1,memory_order_relaxed);
+}
+
+static void b(void *obj)
+{
+ (void)atomic_load_explicit(&x1, memory_order_relaxed);
+ atomic_store_explicit(&x2, 1,memory_order_relaxed);
+}
+
+static void c(void *obj)
+{
+ (void)atomic_load_explicit(&x2, memory_order_relaxed);
+ atomic_store_explicit(&x3, 1,memory_order_relaxed);
+}
+
+static void d(void *obj)
+{
+ (void)atomic_load_explicit(&x3, memory_order_relaxed);
+ atomic_store_explicit(&x4, 1,memory_order_relaxed);
+}
+
+static void e(void *obj)
+{
+ (void)atomic_load_explicit(&x4, memory_order_relaxed);
+ atomic_store_explicit(&x5, 1,memory_order_relaxed);
+}
+
+static void f(void *obj)
+{
+ (void)atomic_load_explicit(&x5, memory_order_relaxed);
+ atomic_store_explicit(&x6, 1,memory_order_relaxed);
+}
+
+static void g(void *obj)
+{
+ (void)atomic_load_explicit(&x6, memory_order_relaxed);
+ atomic_store_explicit(&x7, 1,memory_order_relaxed);
+}
+static void h(void *obj)
+{
+ (void)atomic_load_explicit(&x7, memory_order_relaxed);
+ (void)atomic_load_explicit(&x1, memory_order_relaxed);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2, t3, t4, t5, t6, t7, t8;
+ atomic_init(&x1, 0);
+ atomic_init(&x2, 0);
+ atomic_init(&x3, 0);
+ atomic_init(&x4, 0);
+ atomic_init(&x5, 0);
+ atomic_init(&x6, 0);
+ atomic_init(&x7, 0);
+
+
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+ thrd_create(&t3, (thrd_start_t)&c, NULL);
+ thrd_create(&t4, (thrd_start_t)&d, NULL);
+ thrd_create(&t5, (thrd_start_t)&e, NULL);
+ thrd_create(&t6, (thrd_start_t)&f, NULL);
+ thrd_create(&t7, (thrd_start_t)&g, NULL);
+ thrd_create(&t8, (thrd_start_t)&h, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ thrd_join(t3);
+ thrd_join(t4);
+ thrd_join(t5);
+ thrd_join(t6);
+ thrd_join(t7);
+ thrd_join(t8);
+
+ return 0;
+}
--- /dev/null
+#include <stdio.h>
+#include <threads.h>
+#include <stdatomic.h>
+#include "librace.h"
+ atomic_int x1;
+ atomic_int x2;
+ atomic_int x3;
+ atomic_int x4;
+ atomic_int x5;
+ atomic_int x6;
+ atomic_int x7;
+static void a(void *obj)
+{
+ atomic_store_explicit(&x1, 1,memory_order_seq_cst);
+}
+
+static void b(void *obj)
+{
+ (void)atomic_load_explicit(&x1, memory_order_seq_cst);
+ atomic_store_explicit(&x2, 1,memory_order_seq_cst);
+}
+
+static void c(void *obj)
+{
+ (void)atomic_load_explicit(&x2, memory_order_seq_cst);
+ atomic_store_explicit(&x3, 1,memory_order_seq_cst);
+}
+
+static void d(void *obj)
+{
+ (void)atomic_load_explicit(&x3, memory_order_seq_cst);
+ atomic_store_explicit(&x4, 1,memory_order_seq_cst);
+}
+
+static void e(void *obj)
+{
+ (void)atomic_load_explicit(&x4, memory_order_seq_cst);
+ atomic_store_explicit(&x5, 1,memory_order_seq_cst);
+}
+
+static void f(void *obj)
+{
+ (void)atomic_load_explicit(&x5, memory_order_seq_cst);
+ atomic_store_explicit(&x6, 1,memory_order_seq_cst);
+}
+
+static void g(void *obj)
+{
+ (void)atomic_load_explicit(&x6, memory_order_seq_cst);
+ atomic_store_explicit(&x7, 1,memory_order_seq_cst);
+}
+static void h(void *obj)
+{
+ (void)atomic_load_explicit(&x7, memory_order_seq_cst);
+ (void)atomic_load_explicit(&x1, memory_order_seq_cst);
+}
+
+int user_main(int argc, char **argv)
+{
+ thrd_t t1, t2, t3, t4, t5, t6, t7, t8;
+ atomic_init(&x1, 0);
+ atomic_init(&x2, 0);
+ atomic_init(&x3, 0);
+ atomic_init(&x4, 0);
+ atomic_init(&x5, 0);
+ atomic_init(&x6, 0);
+ atomic_init(&x7, 0);
+
+
+ thrd_create(&t1, (thrd_start_t)&a, NULL);
+ thrd_create(&t2, (thrd_start_t)&b, NULL);
+ thrd_create(&t3, (thrd_start_t)&c, NULL);
+ thrd_create(&t4, (thrd_start_t)&d, NULL);
+ thrd_create(&t5, (thrd_start_t)&e, NULL);
+ thrd_create(&t6, (thrd_start_t)&f, NULL);
+ thrd_create(&t7, (thrd_start_t)&g, NULL);
+ thrd_create(&t8, (thrd_start_t)&h, NULL);
+
+ thrd_join(t1);
+ thrd_join(t2);
+ thrd_join(t3);
+ thrd_join(t4);
+ thrd_join(t5);
+ thrd_join(t6);
+ thrd_join(t7);
+ thrd_join(t8);
+
+ return 0;
+}
--- /dev/null
+/** @file threads-model.h
+ * @brief Model Checker Thread class.
+ */
+
+#ifndef __THREADS_MODEL_H__
+#define __THREADS_MODEL_H__
+
+#include <stdint.h>
+
+#include "mymemory.h"
+#include <threads.h>
+#include "modeltypes.h"
+#include "stl-model.h"
+#include "context.h"
+
+struct thread_params {
+ thrd_start_t func;
+ void *arg;
+};
+
+/** @brief Represents the state of a user Thread */
+typedef enum thread_state {
+ /** Thread was just created and hasn't run yet */
+ THREAD_CREATED,
+ /** Thread is running */
+ THREAD_RUNNING,
+ /** Thread is not currently running but is ready to run */
+ THREAD_READY,
+ /**
+ * Thread is waiting on another action (e.g., thread completion, lock
+ * release, etc.)
+ */
+ THREAD_BLOCKED,
+ /** Thread has completed its execution */
+ THREAD_COMPLETED
+} thread_state;
+
+class ModelAction;
+
+/** @brief A Thread is created for each user-space thread */
+class Thread {
+public:
+ Thread(thread_id_t tid);
+ Thread(thread_id_t tid, thrd_t *t, void (*func)(void *), void *a, Thread *parent);
+ ~Thread();
+ void complete();
+
+ static int swap(ucontext_t *ctxt, Thread *t);
+ static int swap(Thread *t, ucontext_t *ctxt);
+
+ thread_state get_state() const { return state; }
+ void set_state(thread_state s);
+ thread_id_t get_id() const;
+ thrd_t get_thrd_t() const { return *user_thread; }
+ Thread * get_parent() const { return parent; }
+
+ void set_creation(ModelAction *act) { creation = act; }
+ ModelAction * get_creation() const { return creation; }
+
+ /**
+ * Set a return value for the last action in this thread (e.g., for an
+ * atomic read).
+ * @param value The value to return
+ */
+ void set_return_value(uint64_t value) { last_action_val = value; }
+
+ /**
+ * Retrieve a return value for the last action in this thread. Used,
+ * for instance, for an atomic read to return the 'read' value. Should
+ * be called from a user context.
+ * @return The value 'returned' by the action
+ */
+ uint64_t get_return_value() const { return last_action_val; }
+
+ /** @return True if this thread is finished executing */
+ bool is_complete() const { return state == THREAD_COMPLETED; }
+
+ /** @return True if this thread is blocked */
+ bool is_blocked() const { return state == THREAD_BLOCKED; }
+
+ /** @return The pending (next) ModelAction for this Thread
+ * @see Thread::pending */
+ ModelAction * get_pending() const { return pending; }
+
+ /** @brief Set the pending (next) ModelAction for this Thread
+ * @param act The pending ModelAction
+ * @see Thread::pending */
+ void set_pending(ModelAction *act) { pending = act; }
+
+ Thread * waiting_on() const;
+ bool is_waiting_on(const Thread *t) const;
+
+ bool is_model_thread() const { return model_thread; }
+
+ friend void thread_startup();
+
+ /**
+ * Intentionally NOT allocated with MODELALLOC or SNAPSHOTALLOC.
+ * Threads should be allocated on the user's normal (snapshotting) heap
+ * to allow their allocation/deallocation to follow the same pattern as
+ * the rest of the backtracked/replayed program.
+ */
+ void * operator new(size_t size) {
+ return Thread_malloc(size);
+ }
+ void operator delete(void *p, size_t size) {
+ Thread_free(p);
+ }
+ void * operator new[](size_t size) {
+ return Thread_malloc(size);
+ }
+ void operator delete[](void *p, size_t size) {
+ Thread_free(p);
+ }
+private:
+ int create_context();
+
+ /** @brief The parent Thread which created this Thread */
+ Thread * const parent;
+
+ /** @brief The THREAD_CREATE ModelAction which created this Thread */
+ ModelAction *creation;
+
+ /**
+ * @brief The next ModelAction to be run by this Thread
+ *
+ * This action should be kept updated by the ModelChecker, so that we
+ * always know what the next ModelAction's memory_order, action type,
+ * and location are.
+ */
+ ModelAction *pending;
+
+ void (*start_routine)(void *);
+ void *arg;
+ ucontext_t context;
+ void *stack;
+ thrd_t *user_thread;
+ thread_id_t id;
+ thread_state state;
+
+ /**
+ * The value returned by the last action in this thread
+ * @see Thread::set_return_value()
+ * @see Thread::get_return_value()
+ */
+ uint64_t last_action_val;
+
+ /** @brief Is this Thread a special model-checker thread? */
+ const bool model_thread;
+};
+
+Thread * thread_current();
+
+static inline thread_id_t thrd_to_id(thrd_t t)
+{
+ return t.priv->get_id();
+}
+
+/**
+ * @brief Map a zero-based integer index to a unique thread ID
+ *
+ * This is the inverse of id_to_int
+ */
+static inline thread_id_t int_to_id(int i)
+{
+ return i;
+}
+
+/**
+ * @brief Map a unique thread ID to a zero-based integer index
+ *
+ * This is the inverse of int_to_id
+ */
+static inline int id_to_int(thread_id_t id)
+{
+ return id;
+}
+
+#endif /* __THREADS_MODEL_H__ */
--- /dev/null
+/** @file threads.cc
+ * @brief Thread functions.
+ */
+
+#include <string.h>
+
+#include <threads.h>
+#include <mutex>
+#include "common.h"
+#include "threads-model.h"
+#include "action.h"
+
+/* global "model" object */
+#include "model.h"
+
+/** Allocate a stack for a new thread. */
+static void * stack_allocate(size_t size)
+{
+ return snapshot_malloc(size);
+}
+
+/** Free a stack for a terminated thread. */
+static void stack_free(void *stack)
+{
+ snapshot_free(stack);
+}
+
+/**
+ * @brief Get the current Thread
+ *
+ * Must be called from a user context
+ *
+ * @return The currently executing thread
+ */
+Thread * thread_current(void)
+{
+ ASSERT(model);
+ return model->get_current_thread();
+}
+
+/**
+ * Provides a startup wrapper for each thread, allowing some initial
+ * model-checking data to be recorded. This method also gets around makecontext
+ * not being 64-bit clean
+ */
+void thread_startup()
+{
+ Thread * curr_thread = thread_current();
+
+ /* Add dummy "start" action, just to create a first clock vector */
+ model->switch_to_master(new ModelAction(THREAD_START, std::memory_order_seq_cst, curr_thread));
+
+ /* Call the actual thread function */
+ curr_thread->start_routine(curr_thread->arg);
+
+ /* Finish thread properly */
+ model->switch_to_master(new ModelAction(THREAD_FINISH, std::memory_order_seq_cst, curr_thread));
+}
+
+/**
+ * Create a thread context for a new thread so we can use
+ * setcontext/getcontext/swapcontext to swap it out.
+ * @return 0 on success; otherwise, non-zero error condition
+ */
+int Thread::create_context()
+{
+ int ret;
+
+ ret = getcontext(&context);
+ if (ret)
+ return ret;
+
+ /* Initialize new managed context */
+ stack = stack_allocate(STACK_SIZE);
+ context.uc_stack.ss_sp = stack;
+ context.uc_stack.ss_size = STACK_SIZE;
+ context.uc_stack.ss_flags = 0;
+ context.uc_link = model->get_system_context();
+ makecontext(&context, thread_startup, 0);
+
+ return 0;
+}
+
+/**
+ * Swaps the current context to another thread of execution. This form switches
+ * from a user Thread to a system context.
+ * @param t Thread representing the currently-running thread. The current
+ * context is saved here.
+ * @param ctxt Context to which we will swap. Must hold a valid system context.
+ * @return Does not return, unless we return to Thread t's context. See
+ * swapcontext(3) (returns 0 for success, -1 for failure).
+ */
+int Thread::swap(Thread *t, ucontext_t *ctxt)
+{
+ t->set_state(THREAD_READY);
+ return model_swapcontext(&t->context, ctxt);
+}
+
+/**
+ * Swaps the current context to another thread of execution. This form switches
+ * from a system context to a user Thread.
+ * @param ctxt System context variable to which to save the current context.
+ * @param t Thread to which we will swap. Must hold a valid user context.
+ * @return Does not return, unless we return to the system context (ctxt). See
+ * swapcontext(3) (returns 0 for success, -1 for failure).
+ */
+int Thread::swap(ucontext_t *ctxt, Thread *t)
+{
+ t->set_state(THREAD_RUNNING);
+ return model_swapcontext(ctxt, &t->context);
+}
+
+
+/** Terminate a thread and free its stack. */
+void Thread::complete()
+{
+ ASSERT(!is_complete());
+ DEBUG("completed thread %d\n", id_to_int(get_id()));
+ state = THREAD_COMPLETED;
+ if (stack)
+ stack_free(stack);
+}
+
+/**
+ * @brief Construct a new model-checker Thread
+ *
+ * A model-checker Thread is used for accounting purposes only. It will never
+ * have its own stack, and it should never be inserted into the Scheduler.
+ *
+ * @param tid The thread ID to assign
+ */
+Thread::Thread(thread_id_t tid) :
+ parent(NULL),
+ creation(NULL),
+ pending(NULL),
+ start_routine(NULL),
+ arg(NULL),
+ stack(NULL),
+ user_thread(NULL),
+ id(tid),
+ state(THREAD_READY), /* Thread is always ready? */
+ last_action_val(0),
+ model_thread(true)
+{
+ memset(&context, 0, sizeof(context));
+}
+
+/**
+ * Construct a new thread.
+ * @param t The thread identifier of the newly created thread.
+ * @param func The function that the thread will call.
+ * @param a The parameter to pass to this function.
+ */
+Thread::Thread(thread_id_t tid, thrd_t *t, void (*func)(void *), void *a, Thread *parent) :
+ parent(parent),
+ creation(NULL),
+ pending(NULL),
+ start_routine(func),
+ arg(a),
+ user_thread(t),
+ id(tid),
+ state(THREAD_CREATED),
+ last_action_val(VALUE_NONE),
+ model_thread(false)
+{
+ int ret;
+
+ /* Initialize state */
+ ret = create_context();
+ if (ret)
+ model_print("Error in create_context\n");
+
+ user_thread->priv = this;
+}
+
+/** Destructor */
+Thread::~Thread()
+{
+ if (!is_complete())
+ complete();
+}
+
+/** @return The thread_id_t corresponding to this Thread object. */
+thread_id_t Thread::get_id() const
+{
+ return id;
+}
+
+/**
+ * Set a thread's THREAD_* state (@see thread_state)
+ * @param s The state to enter
+ */
+void Thread::set_state(thread_state s)
+{
+ ASSERT(s == THREAD_COMPLETED || state != THREAD_COMPLETED);
+ state = s;
+}
+
+/**
+ * Get the Thread that this Thread is immediately waiting on
+ * @return The thread we are waiting on, if any; otherwise NULL
+ */
+Thread * Thread::waiting_on() const
+{
+ if (!pending)
+ return NULL;
+
+ if (pending->get_type() == THREAD_JOIN)
+ return pending->get_thread_operand();
+ else if (pending->is_lock())
+ return (Thread *)pending->get_mutex()->get_state()->locked;
+ return NULL;
+}
+
+/**
+ * Check if this Thread is waiting (blocking) on a given Thread, directly or
+ * indirectly (via a chain of waiting threads)
+ *
+ * @param t The Thread on which we may be waiting
+ * @return True if we are waiting on Thread t; false otherwise
+ */
+bool Thread::is_waiting_on(const Thread *t) const
+{
+ Thread *wait;
+ for (wait = waiting_on(); wait != NULL; wait = wait->waiting_on())
+ if (wait == t)
+ return true;
+ return false;
+}
--- /dev/null
+#ifndef TRACE_ANALYSIS_H
+#define TRACE_ANALYSIS_H
+#include "model.h"
+
+class TraceAnalysis {
+ public:
+ /** setExecution is called once after installation with a reference to
+ * the ModelExecution object. */
+
+ virtual void setExecution(ModelExecution * execution) = 0;
+
+ /** analyze is called once for each feasible trace with the complete
+ * action_list object. */
+
+ virtual void analyze(action_list_t *) = 0;
+
+ /** name returns the analysis name string */
+
+ virtual const char * name() = 0;
+
+ /** Each analysis option is passed into the option method. This
+ * occurs before installation (i.e., you don't have a
+ * ModelExecution object yet). A TraceAnalysis object should
+ * support the option "help" */
+
+ virtual bool option(char *) = 0;
+
+ /** The finish method is called once at the end. This should be
+ * used to print out results. */
+
+ virtual void finish() = 0;
+
+ SNAPSHOTALLOC
+};
+#endif
--- /dev/null
+/**
+ * @file workqueue.h
+ * @brief Provides structures for queueing ModelChecker actions to be taken
+ */
+
+#ifndef __WORKQUEUE_H__
+#define __WORKQUEUE_H__
+
+#include "mymemory.h"
+#include "stl-model.h"
+
+class ModelAction;
+
+typedef enum {
+ WORK_NONE = 0, /**< No work to be done */
+ WORK_CHECK_CURR_ACTION, /**< Check the current action; used for the
+ first action of the work loop */
+ WORK_CHECK_RELEASE_SEQ, /**< Check if any pending release sequences
+ are resolved */
+ WORK_CHECK_MO_EDGES, /**< Check if new mo_graph edges can be added */
+} model_work_t;
+
+/**
+ */
+class WorkQueueEntry {
+ public:
+ /** @brief Type of work queue entry */
+ model_work_t type;
+
+ /**
+ * @brief Object affected
+ * @see CheckRelSeqWorkEntry
+ */
+ void *location;
+
+ /**
+ * @brief The ModelAction to work on
+ * @see MOEdgeWorkEntry
+ */
+ ModelAction *action;
+};
+
+/**
+ * @brief Work: perform initial promise, mo_graph checks on the current action
+ *
+ * This WorkQueueEntry performs the normal, first-pass checks for a ModelAction
+ * that is currently being explored. The current ModelAction (@a action) is the
+ * only relevant parameter to this entry.
+ */
+class CheckCurrWorkEntry : public WorkQueueEntry {
+ public:
+ /**
+ * @brief Constructor for a "check current action" work entry
+ * @param curr The current action
+ */
+ CheckCurrWorkEntry(ModelAction *curr) {
+ type = WORK_CHECK_CURR_ACTION;
+ location = NULL;
+ action = curr;
+ }
+};
+
+/**
+ * @brief Work: check an object location for resolved release sequences
+ *
+ * This WorkQueueEntry checks synchronization and the mo_graph for resolution
+ * of any release sequences. The object @a location is the only relevant
+ * parameter to this entry.
+ */
+class CheckRelSeqWorkEntry : public WorkQueueEntry {
+ public:
+ /**
+ * @brief Constructor for a "check release sequences" work entry
+ * @param l The location which must be checked for release sequences
+ */
+ CheckRelSeqWorkEntry(void *l) {
+ type = WORK_CHECK_RELEASE_SEQ;
+ location = l;
+ action = NULL;
+ }
+};
+
+/**
+ * @brief Work: check a ModelAction for new mo_graph edges
+ *
+ * This WorkQueueEntry checks for new mo_graph edges for a particular
+ * ModelAction (e.g., that was just generated or that updated its
+ * synchronization). The ModelAction @a action is the only relevant parameter
+ * to this entry.
+ */
+class MOEdgeWorkEntry : public WorkQueueEntry {
+ public:
+ /**
+ * @brief Constructor for a mo_edge work entry
+ * @param updated The ModelAction which was updated, triggering this work
+ */
+ MOEdgeWorkEntry(ModelAction *updated) {
+ type = WORK_CHECK_MO_EDGES;
+ location = NULL;
+ action = updated;
+ }
+};
+
+/** @brief typedef for the work queue type */
+typedef ModelList<WorkQueueEntry> work_queue_t;
+
+#endif /* __WORKQUEUE_H__ */
projects / cdsspec-compiler.git / commitdiff