<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd" [
  <!ENTITY % thread.entities SYSTEM "entities.xml">
  %thread.entities;
]>
<!-- Copyright (c) 2002-2003 William E. Kempf, Michael Glassford
     Subject to the Boost Software License, Version 1.0. 
     (See accompanying file LICENSE-1.0 or  http://www.boost.org/LICENSE-1.0)
-->
<glossary id="thread.glossary" last-revision="$Date: 2006/10/15 14:52:53 $">
  <title>Glossary</title>
  <para>Definitions are given in terms of the C++ Standard
  &cite.ISO98;. References to the standard are in the form [1.2.3/4], which
  represents the section number, with the paragraph number following the
  "/".</para>
  <para>Because the definitions are written in something akin to "standardese",
  they can be difficult to understand. The intent isn't to confuse, but rather
  to clarify the additional requirements &Boost.Thread; places on a C++
  implementation as defined by the C++ Standard.</para>
  <glossentry id="thread.glossary.thread">
    <glossterm>Thread</glossterm>
    <glossdef>
	  <para>Thread is short for "thread of execution". A thread of execution is
	  an execution environment [1.9/7] within the execution environment of a C++
	  program [1.9]. The main() function [3.6.1] of the program is the initial
	  function of the initial thread. A program in a multithreading environment
	  always has an initial thread even if the program explicitly creates no
	  additional threads.</para>
      <para>Unless otherwise specified, each thread shares all aspects of its
	  execution environment with other threads in the program. Shared aspects of
	  the execution environment include, but are not limited to, the
	  following:</para>
	  <itemizedlist>
        <listitem><para>Static storage duration (static, extern) objects
		[3.7.1].</para></listitem>
	    <listitem><para>Dynamic storage duration (heap) objects [3.7.3]. Thus
		each memory allocation will return a unique addresses, regardless of the
		thread making the allocation request.</para></listitem>
        <listitem><para>Automatic storage duration (stack) objects [3.7.2]
		accessed via pointer or reference from another thread.</para></listitem>
        <listitem><para>Resources provided by the operating system. For example,
		files.</para></listitem>
        <listitem><para>The program itself. In other words, each thread is
		executing some function of the same program, not a totally different
		program.</para></listitem>
      </itemizedlist>
      <para>Each thread has its own:</para>
      <itemizedlist>
        <listitem><para>Registers and current execution sequence (program
		counter) [1.9/5].</para></listitem>
        <listitem><para>Automatic storage duration (stack) objects
		[3.7.2].</para></listitem>
      </itemizedlist>
    </glossdef>
  </glossentry>
  <glossentry id="thread.glossary.thread-safe">
    <glossterm>Thread-safe</glossterm>
	<glossdef>
      <para>A program is thread-safe if it has no <link
	  linkend="thread.glossary.race-condition">race conditions</link>, does
	  not <link linkend="thread.glossary.deadlock">deadlock</link>, and has
	  no <link linkend="thread.glossary.priority-failure">priority
	  failures</link>.</para>
	  <para>Note that thread-safety does not necessarily imply efficiency, and
	  than while some thread-safety violations can be determined statically at
	  compile time, many thread-safety errors can only only be detected at
	  runtime.</para>
	</glossdef>
  </glossentry>
  <glossentry id="thread.glossary.thread-state">
    <glossterm>Thread State</glossterm>
	<glossdef>
      <para>During the lifetime of a thread, it shall be in one of the following
	  states:</para>
	  <table>
		<title>Thread States</title>
		<tgroup cols="2" align="left">
			<thead>
				<row>
					<entry>State</entry>
					<entry>Description</entry>
				</row>
			</thead>
			<tbody>
				<row>
					<entry>Ready</entry>
					<entry>Ready to run, but waiting for a processor.</entry>
				</row>
				<row>
					<entry>Running</entry>
					<entry>Currently executing on a processor. Zero or more threads
					may be running at any time, with a maximum equal to the number of
					processors.</entry>
				</row>
				<row>
					<entry>Blocked</entry>
					<entry>Waiting for some resource other than a processor which is
					not currently available, or for the completion of calls to library
					functions [1.9/6]. The term "waiting" is synonymous with
					"blocked"</entry>
				</row>
				<row>
					<entry>Terminated</entry>
					<entry>Finished execution but not yet detached or joined.</entry>
				</row>
			</tbody>
		</tgroup>
	  </table>
      <para>Thread state transitions shall occur only as specified:</para>
	  <table>
		<title>Thread States Transitions</title>
		<tgroup cols="3" align="left">
			<thead>
				<row>
					<entry>From</entry>
					<entry>To</entry>
					<entry>Cause</entry>
				</row>
			</thead>
			<tbody>
				<row>
					<entry>[none]</entry>
					<entry>Ready</entry>
					<entry><para>Thread is created by a call to a library function. 
					In the case of the initial thread, creation is implicit and 
					occurs during the startup of the main() function [3.6.1].</para></entry>
				</row>
				<row>
					<entry>Ready</entry>
					<entry>Running</entry>
					<entry><para>Processor becomes available.</para></entry>
				</row>
				<row>
					<entry>Running</entry>
					<entry>Ready</entry>
					<entry>Thread preempted.</entry>
				</row>
				<row>
					<entry>Running</entry>
					<entry>Blocked</entry>
					<entry>Thread calls a library function which waits for a resource or
					for the completion of I/O.</entry>
				</row>
				<row>
					<entry>Running</entry>
					<entry>Terminated</entry>
					<entry>Thread returns from its initial function, calls a thread
					termination library function, or is canceled by some other thread
					calling a thread termination library function.</entry>
				</row>
				<row>
					<entry>Blocked</entry>
					<entry>Ready</entry>
					<entry>The resource being waited for becomes available, or the
					blocking library function completes.</entry>
				</row>
				<row>
					<entry>Terminated</entry>
					<entry>[none]</entry>
					<entry>Thread is detached or joined by some other thread calling the
					appropriate library function, or by program termination
					[3.6.3].</entry>
				</row>
			</tbody>
		</tgroup>
      </table>
      <para>[Note: if a suspend() function is added to the threading library,
	  additional transitions to the blocked state will have to be added to the
	  above table.]</para>
    </glossdef>
  </glossentry>
  <glossentry id="thread.glossary.race-condition">
    <glossterm>Race Condition</glossterm>
	<glossdef>
      <para>A race condition is what occurs when multiple threads read from and write
	  to the same memory without proper synchronization, resulting in an incorrect
	  value being read or written. The result of a race condition may be a bit
	  pattern which isn't even a valid value for the data type. A race condition
	  results in undefined behavior [1.3.12].</para>
      <para>Race conditions can be prevented by serializing memory access using
	  the tools provided by &Boost.Thread;.</para>
    </glossdef>
  </glossentry>
  <glossentry id="thread.glossary.deadlock">
    <glossterm>Deadlock</glossterm>
	<glossdef>
      <para>Deadlock is an execution state where for some set of threads, each
	  thread in the set is blocked waiting for some action by one of the other
	  threads in the set. Since each is waiting on the others, none will ever
	  become ready again.</para>
	</glossdef>
  </glossentry>
  <glossentry id="thread.glossary.starvation">
    <glossterm>Starvation</glossterm>
	<glossdef>
	  <para>The condition in which a thread is not making sufficient progress in
	  its work during a given time interval.</para>
	</glossdef>
  </glossentry>
  <glossentry id="thread.glossary.priority-failure">
    <glossterm>Priority Failure</glossterm>
	<glossdef>
	  <para>A priority failure (such as priority inversion or infinite overtaking)
	  occurs when threads are executed in such a sequence that required work is not
	  performed in time to be useful.</para>
	</glossdef>
  </glossentry>
  <glossentry id="thread.glossary.undefined-behavior">
    <glossterm>Undefined Behavior</glossterm>
	<glossdef>
	  <para>The result of certain operations in &Boost.Thread; is undefined;
	  this means that those operations can invoke almost any behavior when
	  they are executed.</para>
	  
	  <para>An operation whose behavior is undefined can work "correctly"
	  in some implementations (i.e., do what the programmer thought it
	  would do), while in other implementations it may exhibit almost
	  any "incorrect" behavior--such as returning an invalid value,
	  throwing an exception, generating an access violation, or terminating 
	  the process.</para>
	  
	  <para>Executing a statement whose behavior is undefined is a
	  programming error.</para>
	</glossdef>
  </glossentry>
  <glossentry id="thread.glossary.memory-visibility">
    <glossterm>Memory Visibility</glossterm>
	<glossdef>
	  <para>An address [1.7] shall always point to the same memory byte,
	  regardless of the thread or processor dereferencing the address.</para>
      <para>An object [1.8, 1.9] is accessible from multiple threads if it is of
	  static storage duration (static, extern) [3.7.1], or if a pointer or
	  reference to it is explicitly or implicitly dereferenced in multiple
	  threads.</para>
	  <para>For an object accessible from multiple threads, the value of the
	  object accessed from one thread may be indeterminate or different from the
	  value accessed from another thread, except under the conditions specified in
	  the following table. For the same row of the table, the value of an object
	  accessible at the indicated sequence point in thread A will be determinate
	  and the same if accessed at or after the indicated sequence point in thread
	  B, provided the object is not otherwise modified. In the table, the
	  "sequence point at a call" is the sequence point after the evaluation of all
	  function arguments [1.9/17], while the "sequence point after a call" is the
	  sequence point after the copying of the returned value... [1.9/17].</para>
      <table>
		<title>Memory Visibility</title>
		<tgroup cols="2">
			<thead>
				<row>
					<entry>Thread A</entry>
					<entry>Thread B</entry>
				</row>
			</thead>
			<tbody>
				<row>
					<entry>The sequence point at a call to a library thread-creation
					function.</entry>
					<entry>The first sequence point of the initial function in the new
					thread created by the Thread A call.</entry>
				</row>
				<row>
					<entry>The sequence point at a call to a library function which
					locks a mutex, directly or by waiting for a condition
					variable.</entry>
					<entry>The sequence point after a call to a library function which
					unlocks the same mutex.</entry>
				</row>
				<row>
					<entry>The last sequence point before thread termination.</entry>
					<entry>The sequence point after a call to a library function which
					joins the terminated thread.</entry>
				</row>
				<row>
					<entry>The sequence point at a call to a library function which
					signals or broadcasts a condition variable.</entry>
					<entry>The sequence point after the call to the library function
					which was waiting on that same condition variable or signal.</entry>
				</row>
			</tbody>
		</tgroup>
      </table>
      <para>The architecture of the execution environment and the observable
	  behavior of the abstract machine [1.9] shall be the same on all
	  processors.</para>
	  <para>The latitude granted by the C++ standard for an implementation to
	  alter the definition of observable behavior of the abstract machine to
	  include additional library I/O functions [1.9/6] is extended to include
	  threading library functions.</para>
	  <para>When an exception is thrown and there is no matching exception handler
	  in the same thread, behavior is undefined. The preferred behavior is the
	  same as when there is no matching exception handler in a program
	  [15.3/9]. That is, terminate() is called, and it is implementation-defined
	  whether or not the stack is unwound.</para>
    </glossdef>
  </glossentry>
  <section>
    <title>Acknowledgements</title>
    <para>This document was originally written by Beman Dawes, and then much
	improved by the incorporation of comments from William Kempf, who now
	maintains the contents.</para>
	<para>The visibility rules are based on &cite.Butenhof97;.</para>
  </section>
</glossary>
