Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r56762 - in sandbox/interthreads: doc doc/html doc/html/images doc/html/images/callouts libs/interthreads/build libs/interthreads/doc libs/interthreads/doc/html libs/interthreads/doc/html/toward_boost_interthreads libs/interthreads/doc/html/toward_boost_interthreads/appendices libs/interthreads/doc/html/toward_boost_interthreads/examples libs/interthreads/doc/html/toward_boost_interthreads/overview libs/interthreads/doc/html/toward_boost_interthreads/reference libs/interthreads/doc/html/toward_boost_interthreads/users_guide libs/interthreads/doc/reference libs/interthreads/test
From: vicente.botet_at_[hidden]
Date: 2009-10-12 17:42:31

Author: viboes
Date: 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
New Revision: 56762
URL: http://svn.boost.org/trac/boost/changeset/56762

Log:
TBoost.Interthreads:
* Added doc

Added:
   sandbox/interthreads/doc/
   sandbox/interthreads/doc/html/
   sandbox/interthreads/doc/html/boostbook.css (contents, props changed)
   sandbox/interthreads/doc/html/images/
   sandbox/interthreads/doc/html/images/Thumbs.db (contents, props changed)
   sandbox/interthreads/doc/html/images/alert.png (contents, props changed)
   sandbox/interthreads/doc/html/images/blank.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/
   sandbox/interthreads/doc/html/images/callouts/1.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/10.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/11.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/12.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/13.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/14.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/15.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/2.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/3.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/4.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/5.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/6.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/7.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/8.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/9.png (contents, props changed)
   sandbox/interthreads/doc/html/images/callouts/Thumbs.db (contents, props changed)
   sandbox/interthreads/doc/html/images/caution.png (contents, props changed)
   sandbox/interthreads/doc/html/images/draft.png (contents, props changed)
   sandbox/interthreads/doc/html/images/home.png (contents, props changed)
   sandbox/interthreads/doc/html/images/important.png (contents, props changed)
   sandbox/interthreads/doc/html/images/next.png (contents, props changed)
   sandbox/interthreads/doc/html/images/next_disabled.png (contents, props changed)
   sandbox/interthreads/doc/html/images/note.png (contents, props changed)
   sandbox/interthreads/doc/html/images/prev.png (contents, props changed)
   sandbox/interthreads/doc/html/images/prev_disabled.png (contents, props changed)
   sandbox/interthreads/doc/html/images/smiley.png (contents, props changed)
   sandbox/interthreads/doc/html/images/tip.png (contents, props changed)
   sandbox/interthreads/doc/html/images/toc-blank.png (contents, props changed)
   sandbox/interthreads/doc/html/images/toc-minus.png (contents, props changed)
   sandbox/interthreads/doc/html/images/toc-plus.png (contents, props changed)
   sandbox/interthreads/doc/html/images/up.png (contents, props changed)
   sandbox/interthreads/doc/html/images/up_disabled.png (contents, props changed)
   sandbox/interthreads/doc/html/images/warning.png (contents, props changed)
   sandbox/interthreads/doc/html/reference.css (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/
   sandbox/interthreads/libs/interthreads/doc/html/index.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/standalone_HTML.manifest (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/acknowledgements.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/changes.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/implementation.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/rationale.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/tests.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/tickets.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/todo.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/examples/
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/examples.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/examples/stm.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/examples/thread_safe_deferred_traces.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/overview/
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/overview.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/overview/motivation.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference/
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference/concepts.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference/thread_array_reference.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference/thread_extensions_reference.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/bibliography.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/getting_started.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/glosary.html (contents, props changed)
   sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/tutorial.html (contents, props changed)
Text files modified:
   sandbox/interthreads/libs/interthreads/build/Jamfile.v2 | 2
   sandbox/interthreads/libs/interthreads/doc/acknowledgements.qbk | 3
   sandbox/interthreads/libs/interthreads/doc/appendices.qbk | 54 ----
   sandbox/interthreads/libs/interthreads/doc/case_studies.qbk | 304 +++++++++----------------
   sandbox/interthreads/libs/interthreads/doc/changes.qbk | 157 -------------
   sandbox/interthreads/libs/interthreads/doc/concepts.qbk | 457 ----------------------------------------
   sandbox/interthreads/libs/interthreads/doc/getting_started.qbk | 54 ----
   sandbox/interthreads/libs/interthreads/doc/implementation.qbk | 14
   sandbox/interthreads/libs/interthreads/doc/installation.qbk | 22 -
   sandbox/interthreads/libs/interthreads/doc/interthreads.qbk | 2
   sandbox/interthreads/libs/interthreads/doc/introduction.qbk | 414 ------------------------------------
   sandbox/interthreads/libs/interthreads/doc/models.qbk | 256 ----------------------
   sandbox/interthreads/libs/interthreads/doc/overview.qbk | 34 --
   sandbox/interthreads/libs/interthreads/doc/rationale.qbk | 4
   sandbox/interthreads/libs/interthreads/doc/reference.qbk | 76 ------
   sandbox/interthreads/libs/interthreads/doc/reference/thread_decorator.qbk | 22 +
   sandbox/interthreads/libs/interthreads/doc/reference/thread_keep_alive.qbk | 12 +
   sandbox/interthreads/libs/interthreads/doc/reference/thread_specific_shared_ptr.qbk | 11
   sandbox/interthreads/libs/interthreads/doc/tests.qbk | 40 ---
   sandbox/interthreads/libs/interthreads/doc/tickets.qbk | 60 ----
   sandbox/interthreads/libs/interthreads/doc/tutorial.qbk | 4
   sandbox/interthreads/libs/interthreads/doc/users_guide.qbk | 17 -
   sandbox/interthreads/libs/interthreads/test/Jamfile.v2 | 13
   23 files changed, 178 insertions(+), 1854 deletions(-)

Added: sandbox/interthreads/doc/html/boostbook.css
==============================================================================
--- (empty file)
+++ sandbox/interthreads/doc/html/boostbook.css 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,538 @@
+/*=============================================================================
+ Copyright (c) 2004 Joel de Guzman
+ http://spirit.sourceforge.net/
+
+ Use, modification and distribution is subject to the Boost Software
+ License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+
+/*=============================================================================
+ Body defaults
+=============================================================================*/
+
+ body
+ {
+ margin: 1em;
+ font-family: sans-serif;
+ }
+
+/*=============================================================================
+ Paragraphs
+=============================================================================*/
+
+ p
+ {
+ text-align: left;
+ font-size: 10pt;
+ line-height: 1.15;
+ }
+
+/*=============================================================================
+ Program listings
+=============================================================================*/
+
+ /* Code on paragraphs */
+ p tt.computeroutput
+ {
+ font-size: 10pt;
+ }
+
+ pre.synopsis
+ {
+ font-size: 10pt;
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+ }
+
+ .programlisting,
+ .screen
+ {
+ font-size: 10pt;
+ display: block;
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+ }
+
+/*=============================================================================
+ Headings
+=============================================================================*/
+
+ h1, h2, h3, h4, h5, h6
+ {
+ text-align: left;
+ margin: 1em 0em 0.5em 0em;
+ font-weight: bold;
+ }
+
+ h1 { font: 140% }
+ h2 { font: bold 140% }
+ h3 { font: bold 130% }
+ h4 { font: bold 120% }
+ h5 { font: italic 110% }
+ h6 { font: italic 100% }
+
+ /* Top page titles */
+ title,
+ h1.title,
+ h2.title
+ h3.title,
+ h4.title,
+ h5.title,
+ h6.title,
+ .refentrytitle
+ {
+ font-weight: bold;
+ margin-bottom: 1pc;
+ }
+
+ h1.title { font-size: 140% }
+ h2.title { font-size: 140% }
+ h3.title { font-size: 130% }
+ h4.title { font-size: 120% }
+ h5.title { font-size: 110% }
+ h6.title { font-size: 100% }
+
+ .section h1
+ {
+ margin: 0em 0em 0.5em 0em;
+ font-size: 140%;
+ }
+
+ .section h2 { font-size: 140% }
+ .section h3 { font-size: 130% }
+ .section h4 { font-size: 120% }
+ .section h5 { font-size: 110% }
+ .section h6 { font-size: 100% }
+
+ /* Code on titles */
+ h1 tt.computeroutput { font-size: 140% }
+ h2 tt.computeroutput { font-size: 140% }
+ h3 tt.computeroutput { font-size: 130% }
+ h4 tt.computeroutput { font-size: 120% }
+ h5 tt.computeroutput { font-size: 110% }
+ h6 tt.computeroutput { font-size: 100% }
+
+/*=============================================================================
+ Author
+=============================================================================*/
+
+ h3.author
+ {
+ font-size: 100%
+ }
+
+/*=============================================================================
+ Lists
+=============================================================================*/
+
+ li
+ {
+ font-size: 10pt;
+ line-height: 1.3;
+ }
+
+ /* Unordered lists */
+ ul
+ {
+ text-align: left;
+ }
+
+ /* Ordered lists */
+ ol
+ {
+ text-align: left;
+ }
+
+/*=============================================================================
+ Links
+=============================================================================*/
+
+ a
+ {
+ text-decoration: none; /* no underline */
+ }
+
+ a:hover
+ {
+ text-decoration: underline;
+ }
+
+/*=============================================================================
+ Spirit style navigation
+=============================================================================*/
+
+ .spirit-nav
+ {
+ text-align: right;
+ }
+
+ .spirit-nav a
+ {
+ color: white;
+ padding-left: 0.5em;
+ }
+
+ .spirit-nav img
+ {
+ border-width: 0px;
+ }
+
+/*=============================================================================
+ Table of contents
+=============================================================================*/
+
+ .toc
+ {
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.1pc 1pc 0.1pc 1pc;
+ font-size: 10pt;
+ line-height: 1.15;
+ }
+
+ .toc-main
+ {
+ width: 600;
+ text-align: center;
+ margin: 1pc 1pc 1pc 10%;
+ padding: 2pc 1pc 3pc 1pc;
+ line-height: 0.1;
+ }
+
+ .boost-toc
+ {
+ float: right;
+ padding: 0.5pc;
+ }
+
+/*=============================================================================
+ Tables
+=============================================================================*/
+
+ .table-title,
+ div.table p.title
+ {
+ margin-left: 4%;
+ padding-right: 0.5em;
+ padding-left: 0.5em;
+ }
+
+ .informaltable table,
+ .table table
+ {
+ width: 92%;
+ margin-left: 4%;
+ margin-right: 4%;
+ }
+
+ div.informaltable table,
+ div.table table
+ {
+ padding: 4px;
+ }
+
+ /* Table Cells */
+ div.informaltable table tr td,
+ div.table table tr td
+ {
+ padding: 0.5em;
+ text-align: left;
+ }
+
+ div.informaltable table tr th,
+ div.table table tr th
+ {
+ padding: 0.5em 0.5em 0.5em 0.5em;
+ border: 1pt solid white;
+ font-size: 120%;
+ }
+
+/*=============================================================================
+ Blurbs
+=============================================================================*/
+
+ div.note,
+ div.tip,
+ div.important,
+ div.caution,
+ div.warning,
+ p.blurb
+ {
+ font-size: 10pt;
+ line-height: 1.2;
+ display: block;
+ margin: 1pc 4% 0pc 4%;
+ padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+ }
+
+ p.blurb img
+ {
+ padding: 1pt;
+ }
+
+/*=============================================================================
+ Variable Lists
+=============================================================================*/
+
+ span.term
+ {
+ font-weight: bold;
+ font-size: 10pt;
+ }
+
+ div.variablelist table tbody tr td
+ {
+ text-align: left;
+ vertical-align: top;
+ padding: 0em 2em 0em 0em;
+ font-size: 10pt;
+ }
+
+ div.variablelist table tbody tr td p
+ {
+ margin: 0em 0em 0.5em 0em;
+ }
+
+ /* Make the terms in definition lists bold */
+ div.variablelist dl dt
+ {
+ font-weight: bold;
+ font-size: 10pt;
+ }
+
+ div.variablelist dl dd
+ {
+ margin: 1em 0em 1em 2em;
+ font-size: 10pt;
+ }
+
+/*=============================================================================
+ Misc
+=============================================================================*/
+
+ /* Title of books and articles in bibliographies */
+ span.title
+ {
+ font-style: italic;
+ }
+
+ span.underline
+ {
+ text-decoration: underline;
+ }
+
+ span.strikethrough
+ {
+ text-decoration: line-through;
+ }
+
+ /* Copyright, Legal Notice */
+ div div.legalnotice p
+ {
+ font-size: 8pt;
+ text-align: left
+ }
+
+/*=============================================================================
+ Colors
+=============================================================================*/
+
+ @media screen
+ {
+ /* Links */
+ a
+ {
+ color: #0C7445;
+ }
+
+ a:visited
+ {
+ color: #663974;
+ }
+
+ h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
+ h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
+ h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
+ {
+ text-decoration: none; /* no underline */
+ color: #000000;
+ }
+
+ /* Syntax Highlighting */
+ .keyword { color: #0000AA; }
+ .identifier { color: #000000; }
+ .special { color: #707070; }
+ .preprocessor { color: #402080; }
+ .char { color: teal; }
+ .comment { color: #800000; }
+ .string { color: teal; }
+ .number { color: teal; }
+ .white_bkd { background-color: #E8FBE9; }
+ .dk_grey_bkd { background-color: #A0DAAC; }
+
+ /* Copyright, Legal Notice */
+ .copyright
+ {
+ color: #666666;
+ font-size: small;
+ }
+
+ div div.legalnotice p
+ {
+ color: #666666;
+ }
+
+ /* Program listing */
+ pre.synopsis
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+ .programlisting,
+ .screen
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+ /* Blurbs */
+ div.note,
+ div.tip,
+ div.important,
+ div.caution,
+ div.warning,
+ p.blurb
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+ /* Table of contents */
+ .toc
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+ /* Table of contents */
+ .toc-main
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+
+ /* Tables */
+ div.informaltable table tr td,
+ div.table table tr td
+ {
+ border: 1px solid #DCDCDC;
+ background-color: #FAFFFB;
+ }
+
+ div.informaltable table tr th,
+ div.table table tr th
+ {
+ background-color: #E3F9E4;
+ border: 1px solid #DCDCDC;
+ }
+
+ /* Misc */
+ span.highlight
+ {
+ color: #00A000;
+ }
+ }
+
+ @media print
+ {
+ /* Links */
+ a
+ {
+ color: black;
+ }
+
+ a:visited
+ {
+ color: black;
+ }
+
+ .spirit-nav
+ {
+ display: none;
+ }
+
+ /* Program listing */
+ pre.synopsis
+ {
+ border: 1px solid gray;
+ background-color: #FAFFFB;
+ }
+
+ .programlisting,
+ .screen
+ {
+ border: 1px solid gray;
+ background-color: #FAFFFB;
+ }
+
+ /* Table of contents */
+ .toc
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+ /* Table of contents */
+ .toc-main
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ background-color: #FAFFFB;
+ }
+
+ .informaltable table,
+ .table table
+ {
+ border: 1px solid #DCDCDC;
+ border-bottom: 3px solid #9D9D9D;
+ border-right: 3px solid #9D9D9D;
+ border-collapse: collapse;
+ background-color: #FAFFFB;
+ }
+
+ /* Tables */
+ div.informaltable table tr td,
+ div.table table tr td
+ {
+ border: 1px solid #DCDCDC;
+ background-color: #FAFFFB;
+ }
+
+ div.informaltable table tr th,
+ div.table table tr th
+ {
+ border: 1px solid #DCDCDC;
+ background-color: #FAFFFB;
+ }
+
+ /* Misc */
+ span.highlight
+ {
+ font-weight: bold;
+ }
+ }

Added: sandbox/interthreads/doc/html/images/Thumbs.db
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/alert.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/blank.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/1.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/10.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/11.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/12.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/13.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/14.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/15.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/2.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/3.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/4.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/5.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/6.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/7.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/8.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/9.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/callouts/Thumbs.db
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/caution.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/draft.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/home.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/important.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/next.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/next_disabled.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/note.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/prev.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/prev_disabled.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/smiley.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/tip.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/toc-blank.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/toc-minus.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/toc-plus.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/up.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/up_disabled.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/images/warning.png
==============================================================================
Binary file. No diff available.

Added: sandbox/interthreads/doc/html/reference.css
==============================================================================
--- (empty file)
+++ sandbox/interthreads/doc/html/reference.css 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,13 @@
+/*=============================================================================
+ Copyright (c) 2004 Joel de Guzman
+ http://spirit.sourceforge.net/
+
+ Use, modification and distribution is subject to the Boost Software
+ License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+ http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+PRE.synopsis {
+ background-color: #e0ffff;
+ border: thin solid blue;
+ padding: 1em
+}

Modified: sandbox/interthreads/libs/interthreads/build/Jamfile.v2
==============================================================================
--- sandbox/interthreads/libs/interthreads/build/Jamfile.v2 (original)
+++ sandbox/interthreads/libs/interthreads/build/Jamfile.v2 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -46,7 +46,7 @@
# <define>BOOST_THREAD_HAS_THREAD_ATTR

 <include>../../..
- <include>/boost_1_39_0
+ <include>$BOOST_ROOT
 <link>static:<define>BOOST_INTERTHREADS_BUILD_LIB=1
 <link>shared:<define>BOOST_INTERTHREADS_BUILD_DLL=1
# <link>shared:<library>/boost/thread//boost_thread/<link>shared

Modified: sandbox/interthreads/libs/interthreads/doc/acknowledgements.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/acknowledgements.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/acknowledgements.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -13,9 +13,6 @@

Thanks also must go to Jochen Heckl for the ideas given respect to the thread_tuple::wait_first implementation.

-The Threader|Joiner design is taken from [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1883.pdf N1833 - Preliminary Threading Library Proposal for TR2]
-Many thanks to Kevlin Henney to make evident to me the separation between asynchonous executors, and asynchronous completion tokens.
-
You can help me to make this library better! Any feedback is very welcome.

[endsect]

Modified: sandbox/interthreads/libs/interthreads/doc/appendices.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/appendices.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/appendices.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -27,87 +27,33 @@
[section Tasks to do before review]

-[heading Add an overloading for wait_for_all_in_sequence(ae, f, seq)]
-
-This will be quite useful on recursive algorithms evaluating asynchronously the same function on different parts.
-
- template <
- typename DirectSolver,
- typename Composer,
- typename AsynchronousExecutor,
- typename Input>
- void inplace_solve(AsynchronousExecutor& ae, Problem& input) {
- // if (problem is small)
- if (size(range) < concurrency_threshold) {
- // directly solve problem
- DirectSolver()(input);
- } else {
- // split problem into independent parts
- BOOST_AUTO(partition, partition_view(input));
- // evaluates asynchronously inplace_solve on each element of the partition
- // using the asynchronous executor as scheduler
- wait_for_all_in_sequence(ae, inplace_solve, partition);
- // compose the result in place from subresults
- Composer()(partition);
- }
- }
-
-
-[heading Add polymorphic act and adapters]
-When we need to chain __ACT__ using the fork_after the nature of the __ACT__ can change over time, an why not change also its
-template parameter. So at least we need to make polymorphic every function used by fork_after.
-
-[heading Use set_once to implement wait_for_any]
-The current implementation uses the Boost.Futures wait_for_any to implement this feauture, which add weigth constraint:
-be able to get a future from all the AE/ACT. As AE/ACT wait_for_any evaluates the function itselfs, he can decorate the
-function and signal the first one.]]
-
[heading Complete the tests]

Even if the current release include some test there is yet a long way before been able to review the library.]]

* change the test so they take less time using locks; conditions and variables.
-* Complete the test for the AE/ACT framework
* Add test with functions throwing
* Formalize the tests for thread_decoratoor
* Formalize the tests for thread_specific_shared_ptr
-* Add tests for asynchronous_executor_decorator, basic_threader_decorator and threader_decorator
* Add tests for keep alive mechanism

[heading Add more examples]

-* Use of the ae/act framework instead of thread_tuples in the Getting Started section.
* Complete the STM example.
-* A a parallel sort
* Change the implementation of the file on the async_ostream.

-[heading Complete the reference]
-
-* ae/act framework
-
[heading Change the rational and implementation sections]

[endsect]

[section For later releases]

-
-[heading Use Boost.Chrono]
-
[heading Add C++0x move semantics on compilers supporting it and use the Boost.Move emulation otherwise]

[heading Use C++0x variadic templates on compilers supporting it and use the preprocesor otherwise]

[heading Use C++0x Concepts on compilers supporting them and use the Boost.ConceptCheck or Boost.ConceptTraits otherwise]

-[heading Add Message queues]
-Messages queue are the next step concerning the communication between threads on the InterThreads library.]
-
-[heading Add Rendez-vous]
-Concurrent components may interact in different ways: they may access the same objects by, for example,
-executing functions of these objects; or they may communicate directly by executing functions of each other.
-These library will provide the so-called rendezvous mechanism for handling direct communication between active objects.]
-
[heading Add a daemon controlling all the keep alive controller threads]
This daemon will send regular keep_alive messages and kill the process when dead.

Modified: sandbox/interthreads/libs/interthreads/doc/case_studies.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/case_studies.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/case_studies.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -13,92 +13,6 @@

[/==================================]
-[section Parallel sort]
-[/==================================]
-
-Next follows a generic algorithm based on partitioning od a given problem in smaler problems, and compose a solution from the solution of the smaller problems.
-
- template <
- typename DirectSolver,
- typename Composer,
- typename AE,
- typename Range
- >
- void inplace_solve( AE & ae,
- boost::iterator_range<typename boost::range_iterator<Range>::type> range,
- unsigned cutoff );
-
- template <
- typename DirectSolver,
- typename Composer,
- typename AE,
- typename Range
- >
- void inplace_solve( AE & ae,
- boost::iterator_range<typename boost::range_iterator<Range>::type> range,
- unsigned cutoff )
- {
- unsigned size = boost::size(range);
- //std::cout << "<<par_ " << size;
- if ( size <= cutoff) DirectSolver()(range);
- else {
- partition<Range> parts(range, BOOST_PARTS);
-
- // wait_for_all_in_sequence(ae, &inplace_solve<DirectSolver,Composer,AE,Range>, parts);
- std::list<task_type> tasks;
- for (unsigned i=0;i < BOOST_PARTS-1; ++i) {
- task_type tmp(ae.submit(
- boost::bind(
- &inplace_solve<DirectSolver,Composer,AE,Range>,
- boost::ref(ae),
- parts[i],
- cutoff
- )));
- tasks.push_back(tmp);
- }
- inplace_solve<DirectSolver,Composer,AE,Range>(ae, parts[BOOST_PARTS-1], cutoff);
- boost::for_each(tasks, &boost::interthreads::wait_act<task_type>);
- // wait_for_all_in_sequence
-
- Composer()(range);
- }
- }
-
-
-So parallel sort could be
-
- struct sort_fct {
- template<class RandomAccessRange>
- RandomAccessRange& operator()(RandomAccessRange rng) {
- return boost::sort(rng);
- }
- };
-
- struct inplace_merge_fct {
- template<class BidirectionalRange>
- BidirectionalRange&
- operator()( BidirectionalRange rng) {
- return boost::inplace_merge(rng, boost::begin(rng)+(boost::size(rng)/2));
- }
- };
- template <typename AE, typename Range>
- void parallel_sort(AE& ae, Range& range, unsigned cutoff=10000) {
- boost::iterator_range<typename boost::range_iterator<Range>::type> rng(range);
- inplace_solve<sort_fct,inplace_merge_fct,pool_type,Range>( ae, rng, cutoff);
- }
-
-
-[endsect]
-
-[/==================================]
-[section From a single to a multi threaded application]
-[/==================================]
-
-
-
-[endsect]
-
-[/==================================]
[section Thread safe deferred traces]
[/==================================]

@@ -403,7 +317,7 @@
 BankAccount* checkingAcct_;
 BankAccount* savingsAcct_;
 AccountManager(BankAccount& checking, BankAccount& savings)
- : checkingAcct_(&checking)
+ : checkingAcct_(&checking)
 , savingsAcct_(&savings)
 {}
 void Checking2Savings(int amount) {
@@ -451,104 +365,113 @@
 };
 }

-Evidently every operation must be atomic.
+Evidently every operation must be atomic. We use the STM_ATOMIC and STM_END_ATOMIC macors to hide all the transaction complexity

 class BankAccount {
 int balance_;
 public:
 void Deposit(unsigned amount) {
- stm::this_tread::atomic _;
- stm::this_tread::make_transactional_ptr(this)->balance_ += amount;
- _.commit();
+ STM_ATOMIC(t) {
+ t.wr_ptr(this)->balance_ += amount;
+ } STM_END_ATOMIC
 }
 // ...

 };

-How all this works? `stm::this_tread::atomic _;` declares the scope of the variable `_` as an atomic transaction.
-To access this in the current transaction we use `stm::make_transactional_ptr(this)` which return a smart pointer.
-If nothing is said the transaction will be aborted at `_` destruction.
-When everything is ok we need to do a `_.commit()`.
-
-If there is a large use of make_transactional_ptr we can write instead
+How all this works? Let me write what what is begind these macros. These macros use a trick to that ensure that when the statement between both macros succeed the transaction is committed. As the transaction can fail (exception transaction_aborted thrown) we need to reiterate the execution of the statement. So what a user needs to write is something like

- {
- stm::this_tread::atomic _;
- stm::this_tread::transactional_ptr<BankAccount> this_ptr(this);
- this_ptr->balance_ += amount;
- _.commit();
+ void Deposit(unsigned amount) {
+ for (stm::transaction t; !t.commited() && t.restart(); t.no_throw_commit()) {
+ try {
+ t.wr_ptr(this)->balance_ += amount;
+ } catch (stm::transaction_aborted&) {}
+ }
 }

-or even shorter with the suggar syntax
+1. creation of a new transaction
+2.a if not commited restart the transaction and enter the body of the for (3)
+2.b if commited exit the for.
+3. execute the statement
+4 catch stm::transaction_aborted - if a stm::transaction_aborted is thrown the next commit will fail
+5. do a no_throw commit (2)
+
+Next follows the definition of the STM_ATOMIC and STM_END_ATOMIC macros.
+
+
+To access this in the current transaction we use `t.wr_ptr(this)` which return a smart pointer.
+
+If there is a large use of t.wr_ptr(this) it is better to use a variable

 {
- stm::this_tread::atomic_transactional_ptr <BankAccount> this_ptr(this);
- this_ptr->balance_ += amount;
- // other uses of this
- // ...
- this_ptr.commit();
+ STM_ATOMIC(t) {
+ stm::tx_wr_ptr<BankAccount> this_ptr(this,t);
+ this_ptr->balance_ += amount;
+ } STM_END_ATOMIC
 }

-The other `BankAccount` functions are coded as expected. Here is the code introducing a `using stm::this_tread;`
-which makes it much more readable.
+The other `BankAccount` functions are coded as expected. Here is the comple code:

 class BankAccount {
 int balance_;
- using stm::this_tread;
+ using stm:;
 public:
 void Deposit(unsigned amount) {
- atomic_ptr<BankAccount> this_ptr(this);
- this_ptr->balance_ += amount;
- this_ptr.commit();
+ STM_ATOMIC(t) {
+ t.wr_ptr(this)->balance_ += amount;
+ } STM_END_ATOMIC
 }
 void Withdraw(unsigned amount) {
- atomic_ptr<BankAccount> this_ptr(this);
- this_ptr->balance_ -= amount;
- this_ptr.commit();
+ STM_ATOMIC(t) {
+ t.wr_ptr(this)->balance_ -= amount;
+ }
 }
 int GetBalance() const {
- atomic_ptr<BankAccount> this_ptr(this);
- int res = this_ptr->balance_;
- this_ptr.commit();
- return res;
+ STM_ATOMIC(t) {
+ return make_tx_rd_ptr(this,t)->balance_;
+ } STM_END_ATOMIC
 }
 };

The transfer from accounts is done like:

 void Transfer(BankAccount* inA, BankAccount* outA, int amount) {
- using stm::this_tread;
- atomic _;
- make_transactional_ptr(inA)->Withdraw(amount);
- make_transactional_ptr(outA)_>Deposit(amount);
- _.commit();
+ using stm;
+ STM_ATOMIC(t) {
+ t.wr_ptr(inA)->Withdraw(amount);
+ t.wr_ptr(outA)->Deposit(amount);
+ } STM_END_ATOMIC
 }

-The core of all this stuff is `stm::this_tread::atomic` and `stm::transactional_ptr<>`.
-`stm::make_transactional_ptr()` and `stm::this_tread::atomic_ptr<>` are defined in terms of `stm::this_tread::atomic` and `stm::transactional_ptr<>`.
+The core of all this stuff is `stm::transaction`, `stm::tx_wr_ptr<>` and `stm::tx_rd_ptr<>`.
+
+The interface of the transaction class is quite simple:
+
+ class transaction {
+ public:
+ bool commit();
+ bool no_throw_commit() throw();
+ void abort();
+
+ template <typename T>
+ shared_ptr<transactional_object_cache<T> > rd_ptr(T* ptr);
+
+ template <typename T>
+ shared_ptr<transactional_object_cache<T> > wr_ptr(T* ptr);
+
+ template <typename T> void delete_memory(T* ptr);
+ template <typename T>
+ shared_ptr<transactional_object_cache<T> > insert_in_new_cache(T* ptr);

-Next follows the interface of the atomic class.
+ transaction_state const & state() const;
+ };

- namespace stm {
- namespace this_thread {
- class atomic {
- public:
- atomic();
- ~atomic();
- void rollback();
- };
- } // this_transaction
- } // stm
-
-The atomic constructor will construct a
-transaction on the current thread and push it to the stack of nested transactions.
-The atomic destructor will rollback the transaction if not commited and pop the stack of nested transactions.
-We will see later the transaction class.

-The transactional_ptr<> smart pointer interface follows:
+
+The smart pointer interfaces follows:

 template <typename T>
- class transactional_ptr {
+ class tx_rd_ptr {
 public:

 typedef T element_type;
@@ -556,43 +479,45 @@
 typedef T * pointer;
 typedef T& reference;

- transactional_ptr(T* p, transaction* tr=0);
- transactional_ptr(T* p, this_thread::atomic& scope);
+ tx_rd_ptr(T* p, transaction& scope);

- transactional_ptr(T* p, writable&tag, transaction* tr=0));
- transactional_ptr(T* p, writable&tag, this_thread::atomic& scope);
+ const T* operator->() const;
+ const T& operator*() const;
+ const T * get() const;
+ };

- transactional_ptr(T* p, is_new&tag, transaction* tr=0));
- transactional_ptr(T* p, is_new&tag, this_thread::atomic& scope);

- const T* operator->() const;
- const T& operator*() const;
- const T * get() const;
+ template <typename T>
+ class tx_wr_ptr {
+ public:

- T* operator->();
- T& operator*();
- T * get();
+ typedef T element_type;
+ typedef T value_type;
+ typedef T * pointer;
+ typedef T& reference;
+
+ tx_wr_ptr(T* p, transaction& scope);

- void delete_ptr();
+ T* operator->() const;
+ T& operator*() const;
+ T * get() const;
+
+ void delete_ptr();
 };

Let me start with the simple constructor:

- transactional_ptr(T* p);
+ tx_wr_ptr(T* p);

This creates a smart pointer pointing to a specific transaction memory of the current transaction.

It contains the classic functions of a smart pointer overloaded with `const` or non `const`.

- const T* operator->() const;
- const T& operator*() const;
- const T * get() const;
-
- T* operator->();
- T& operator*();
- T * get();
+ T* operator->() const;
+ T& operator*() const;
+ T * get() const;

-By default the `transactional_ptr` points to a read only cache. When we use one of the non const operators,
+`tx_wr_ptr` points to a writable cache. When we use one of the smart pointer operators,
the pointers points to a upgraded write cache specific to the transaction. In the example

 this_ptr->balance_ += amount;
@@ -600,48 +525,45 @@
the use of `this_ptr->balance_` on the left hand side of the assignement operator requires a non const access,
so the upgrade to writable is done.

-When we know a priori that the pointer contents will be modified we can create it as follows:
-
- void Deposit(unsigned amount) {
- atomic _;
- transactional_ptr<BankAccount> this_ptr(this, writable);
- this_ptr->balance_ += amount;
- _.commit();
- }
-
Every `new`/`delete` operation on a transaction must be in some way signaled to the transaction service.
-The new created objects would be wrapped by a `transactional_ptr<>` initialized like that;
+The new created objects would be wrapped by a `tx_wr_ptr<>` initialized like that;

- transactional_ptr<BankAccount> this_ptr(new BackAccount(), is_new);
+ tx_wr_ptr<BankAccount> this_ptr(new BackAccount(), is_new);

-When we want to delete a pointer in a transaction we use `transactional_ptr::delete_ptr`
+When we want to delete a pointer in a transaction we use `tx_wr_ptr::delete_ptr`

- transactional_ptr<BankAccount> p_ptr(p, writable);
+ tx_wr_ptr<BankAccount> p_ptr(p, t);
 // ...
 p_ptr.delete_ptr();
+
+or the short-cut
+
+ t.delete_ptr(p);

Before finishing with the `transaction` class let me show you the
`transactional_object_cache<T>` and its base class `transactional_object_cache_base`.

 class transaction {
 public:
- bool commit();
- void rollback();
- void rollback_only();
+ bool commit();
+ bool no_throw_commit();
+ void abort();

- template <typename T>
- shared_ptr<transactional_object_cache<T> > read(T* ptr);
+ template <typename T>
+ shared_ptr<transactional_object_cache<T> > read(T* ptr);

 template <typename T>
- T* write(T* in);
+ shared_ptr<transactional_object_cache<T> > write(T* ptr);

- template <typename T> void delete_memory(T* in);
- template <typename T>
- shared_ptr<transactional_object_cache<T> > insert_in_new_cache(T* ptr);
+ template <typename T> void delete_memory(T* ptr);
+ template <typename T>
+ shared_ptr<transactional_object_cache<T> > insert_in_new_cache(T* ptr);

- transaction_state const & state() const;
+ transaction_state const & state() const;
 };

+
+
[endsect]

[endsect]

Modified: sandbox/interthreads/libs/interthreads/doc/changes.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/changes.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/changes.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -7,93 +7,18 @@

[section:changes Appendix A: History]

-[section [*Version 0.4.3, May 9, 2009] Adaptation to Boost 1.39
-[endsect]
-
-[section [*Version 0.4.2, Mars 9, 2009] Adaptation to the Boost.ThreadPoold Version 0.23]
+[section [*Version 0.1.3, Mars 29, 2009] Extraction of the Asynchonous Executor framework]

[*New Features:]

-* Adaptation to the Boost.ThreadPoold Version 0.21
+* Extraction of the Asynchonous Executor framework

[endsect]
-[section [*Version 0.4.1, Mars 1, 2009] Adaptation to the Boost.ThreadPoold Version 0.21 + Scoped forking + Parallel sort]
-
-[*New Features:]
-
-* Adaptation to the Boost.ThreadPoold Version 0.21
-
-* Scoped forking: In [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2802.html N2802: A plea to reconsider detach-on-destruction for thread objects]
-Hans-J. Boehm explain why is detaching on destruction so dangerous and gives two solutions: 1) replace the call to detach by a join, 2) replace by a terminate call. The library provides the following classes
-
-* a RAII scoped_join which will join the assocaited act on the destructor if not already joined,
-
- basic_threader ae;
- BOOST_AUTO(act,bith::fork(ae, simple_thread));
- scoped_join<BOOST_TYPEOF(act)> j(act);
-
-* a RAII scoped_terminate which will call to teminate on the destructor if not already joined,
-
- basic_threader ae;
- BOOST_AUTO(act,bith::fork(ae, simple_thread));
- scoped_terminate<BOOST_TYPEOF(act)> j(act);
-
-* a RAII scoped_fork_join which will fork on construction and join the assocaited act on the destructor if not already joined,
-
- basic_threader ae;
- scoped_fork_join<BOOST_TYPEOF(bith::fork(ae, simple_thread)) > act(ae, simple_thread);
-
-* a RAII scoped_fork_terminate which will fork on construction and call to teminate on the destructor if not already joined,
-
- basic_threader ae;
- scoped_fork_terminate<BOOST_TYPEOF(bith::fork(ae, simple_thread) > act(ae, simple_thread);
-
-In addition unique_joiner/shared_joiner have a on_destruction parameter allowing to parameterize this behavior.
-
-
-[/*Tests:
-
-Add tests for move only __ACT__ basic_threader, unique_threader and unique_launcher)
-Change the implementation of the queue on the async_ostream.
-]
-[*Examples:]
-
-* Parallel sort
-
-[/*Documentation:
-
-* Complete ae/act framework.
-]
-[/*Fixed Bugs:]
-
-*]
-
-[endsect]
-
-[section [*Version 0.4.0, February 8, 2009] Improvements + bug fixes]

-[*New Features:]
-
-* New free functions for all the __ACT__ operations, providing a higher degree of freedom.
-* Missing `have_all_values()`, `have_all_exception()` and `are_all_ready()` functions on __ACT__ fusion tuples.
-* `get_all`: getting all the values from a tuple of __ACT__ works now.
-* fork_after overloaded for a single dependency
-* wait_all overloaded for a single ACT.
-* wait_for_all evaluate one of its elements on the current thread
-* No need to use `wait_and_get()` on `thread_specific_shared_ptr<>` to synchronize with the decoration
-if the thread is created using a __AE__ decorator. In this case the synchro is done before returning the __ACT__.
-See the tutorial and the mono_thread_id example.
-
-[*Documentation:]
-
-* New Tickets and test appendices
+[section [*Version 0.1.2, February 8, 2009] Bug fixes]

[*Fixed Bugs:]

-[*v0.2#1: `ae::get_all` do not work yet.]
-`get_all()` do not work because fusion transform sequence function can not take non const sequences.
-I have emulated it using `set_all()` and a transformation for a tuple of __ACT__ to a tuple of result_type.
-
[*v0.3.1#1: keep alive mechanism crash when setting `set_on_dead_thread()` before enabling the mechanism.]
This was due to the fact that there were no default data for the backup.

@@ -106,54 +31,8 @@

[endsect]

-[section [*Version 0.3.1, January 25, 2009] bug fixes]
-
-[*Fixed Bugs:]

-[*v0.3#3: `scheduler::do_test_fork_after_wait` do not work yet.]
-To solve this issue it enough to define boost::move for tp::task
-
-[*v0.3#2: `scheduler::do_test_fork_after_get` do not work yet.]
-To solve this issue it enough to define boost::move for tp::task
-
-[*v0.3#1: `scheduler::do_test_wait_for_any` do not work yet.]
-Not reproductible
-
-[*v0.2#2: Some trouble with the use of `tp::pool` directly, use `scheduler` instead.]
-Four issues.
-
-* The parameter to fork on `tp:pool` was a `const F&` instead of a `F`.
-* Direct use of `fork_all` resolved for the other __AE__ by ADL, which could not be the case for the `tp::pool`.
-* `fork` specialization for `tp::pool` incorrect.
-* use of the default handle instead of `asynchronous_completion_token` traits class
-
-[endsect]
-
-[section [*Version 0.3.0, January 19, 2009] fork after dependant act completes]
-
-[*New Features:]
-
-* `fork_after`: request the __AE__ to execute a function asynchronously once each one of __ACT__ s in the dependency tuple parameter are ready.
-* Add act traits, as value type, is movable, has_future_if, has_thread_if
-
-[endsect]
-
-[section [*Version 0.2.0, January 14, 2009] Asynchronous execution and test on more toolsets]
-
-[*New Features:]
-
-* Asynchronous executors (AE) and asynchronous completion token (ACT) framework
- * `fork` and `fork_all` functions
- * `wait_for_all`, `wait_for_any` functions
- * `set_all`, `join_all`, ...
-* `unique/shared_threader` (AE) and `unique/shared_joiner` (ACT) classes
-* `basic_threader` (AE) class
-* `unique/shared_launcher` (AE) class
-* `scheduler` (AE) class (working with `tp::pool`(AE) and `tp::task<>` (ACT))
-* `thread_decorator` can now decorate a nullary function in addition to a callable function
-* `asynchronous_executor_decorator` mixin allows to decorate the functions launched by an asynchronous executor
-* Boost.Typeof registration for the __ACT__ classes
-* The AE/ACT framework comes with significant tests
+[section [*Version 0.1.1, January 14, 2009] Bug fixes and test on more toolsets]

[*Toolsets:]

@@ -182,40 +61,18 @@

[heading [*Open Bugs:]]

-[*v0.4.0#1: wait_for_any.]

[heading [*Fixed Bugs:]]

-[*v0.3.1#1: keep alive mechanism crash when setting set_on_dead_thread before enabling the mechanism.]
+[*v0.1.1#1: keep alive mechanism crash when setting set_on_dead_thread before enabling the mechanism.]
This was due to the fact that there were no default data for the backup.

-[*v0.3.1#2: keep alive mechanism do not detect dead threads.]
+[*v0.1.1#2: keep alive mechanism do not detect dead threads.]
We need to reste the counters only when the period is 0.

-[*v0.3.1#3: The set_on_dead_thread setting is not recovered by embeeding enablers/disablers.]
+[*v0.1.1#3: The set_on_dead_thread setting is not recovered by embeeding enablers/disablers.]
The problem is that the on_dead and th thread pointer were stored on the backup. It is enough to store them on the

-[*v0.2#1: ae::get_all do not work yet.]
-get_all do not work because fusion transform sequence function can not take non const sequences.
-I have emulated it using set_all and a transformation for a tuple of ACT to a tuple of result_type.
-
-[*v0.3#3: scheduler::do_test_fork_after_wait do not work yet.]
-To solve this issue it enough to define boost::move for tp::task
-
-[*v0.3#2: scheduler::do_test_fork_after_get do not work yet.]
-To solve this issue it enough to define boost::move for tp::task
-
-[*v0.3#1: scheduler::do_test_wait_for_any do not work yet.]
-Not reproductible
-
-[*v0.2#2: Some trouble with the use of tp::pool directly, use scheduler instead.]
-Four issues.
-
-* The parameter to fork on tp:pool was a const F& instead of a F.
-* Direct use of fork_all resolved for the other AE by ADL, which could not be the case fro the tp::pool.
-* fork specialization for tp::pool incorrent.
-* use of the default handle instead of asynchronous_completion_token traits class
-
[*v0.1#1: basic_keep_alive example do not link.]

[endsect]

Modified: sandbox/interthreads/libs/interthreads/doc/concepts.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/concepts.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/concepts.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -16,462 +16,5 @@
[/=============================================]
[endsect]

-[/=============================================]
-[section Asynchronous Completion Token Concepts]
-[/=============================================]
-
-[/==================]
-[section:ACT Concept `ACT` ]
-[/==================]
-
-[heading Description]
-An __ACT__ allows to wait for the completion of an asynchronous executed operation.
-An __ACT__ should be __Movable__ or __CopyConstructible__.
-The completion of the __ACT__ is undefined at this level. Different models could signal this completion when setting a value or an exception.
-
-[heading Notation]
-
-[variablelist
- [[`act`] [An __ACT__]]
- [[`f`] [A __Nullary__ function with type F]]
- [[`abs_time`] [A __system_time__]]
- [[`rel_time`] [A __Duration__]]
- [[`b`] [A bool]]
-]
-
-[heading Expression requirements]
-A type models a __ACT__ if, the following expressions are valid:
-
-[table
- [[Expression] [Return type] [Runtime Complexity]]
- [[`wait(act)`] [void] [Constant]]
- [[`b = wait_until(act, abs_time)`] [bool] [Constant]]
- [[`b = wait_for(act, rel_time)`] [bool] [Constant]]
-]
-
-[heading Meta Expressions]
-[table
- [[Expression] [Type] [Compile Time Complexity]]
- [[`act_traits<ACT>::move_dest_type`] [Any] [Constant]]
- [[`act_traits<ACT>::move_result`] [MPL boolean] [Constant]]
- [[`is_movable<ACT>::type`] [MPL boolean] [Constant]]
- [[`has_future_if<ACT>::type`] [MPL boolean] [Constant]]
- [[`has_thread_if<ACT>::type`] [MPL boolean] [Constant]]
-]
-
-
-
-[heading Expression Semantics]
-[
-table
- [[Expression] [Semantics]]
- [[`wait(act)`] [Blocks until the `act` completes]]
- [[`b = wait_until(act,abs_time)`] [Blocks until the `act` completes or `abs_time` is reached]]
- [[`b = wait_for(act,rel_time)`] [Blocks until the `act` completes or `rel_time` has been elapsed]]
-]
-
-
-[heading Expression `wait(act)`]
-[/==========================================================================================]
-
-
-[variablelist
-[[Effects:] [Blocks until the `act` completes.]]
-[[Sychronization:][The completion of `act` happens before wait() returns.]]
-[[Throws:] [the stored exception, if an exception was stored and not retrieved before.]]
-[[Postconditions:] [is_ready(act) == true.]]
-[[Thread safety:][unsafe]]
-]
-
-[heading Expression `b = wait_until(act,abs_time)`]
-[/==========================================================================================]
-
- bool wait_until(const system_time& abs_time);
- template<typename TimeDuration>
- bool wait_for(TimeDuration const& rel_time);
-
-
-[variablelist
-[[Effects:] [Blocks until the `act` completes or `abs_time` is not reached.]]
-[[Sychronization:][The completion of the `act` happens before wait() returns.]]
-[[Returns:] [true only if the function returns because `act` is ready.]]
-[[Throws:] [the stored exception, if an exception was stored and not retrieved before.]]
-[[Postconditions:] [is_ready() == true.]]
-[[Thread safety:][unsafe]]
-]
-
-[heading Expression `b = wait_for(act,rel_time)`]
-[/==========================================================================================]
-
-
-
-[variablelist
-[[Effects:] [blocks until the `act` completes or `rel_time` has elapsed.]]
-[[Sychronization:][The completion of the `act` happens before wait() returns.]]
-[[Returns:] [true only if the function returns because `act` is ready.]]
-[[Throws:] [the stored exception, if an exception was stored and not retrieved before.]]
-[[Postconditions:] [is_ready() == true.]]
-[[Thread safety:][unsafe]]
-]
-
-[heading Models]
-
-* __unique_future__
-* __shared_future__
-* __unique_joiner__
-* __shared_joiner__
-* __tp_task__
-* __thread__
-
-[endsect]
-
-[/=============================]
-[section:FutureBasedACT Concept `FutureBasedACT` ]
-[/=============================]
-The completion of the __FutureBasedACT__ is undefined at this level but occurs usualy after a set_calue or set_exception on the associated promise.
-
-
-[heading Description]
-
-An __FutureBasedACT__ is a __ACT__ that associates a value expected on the its completion.
-
-[heading Notation]
-
-[variablelist
- [[`act`] [An __ACT__]]
- [[`cact`] [An const __ACT__]]
- [[`f`] [A __Nullary__ function with type F]]
- [[`abs_time`] [A __system_time__]]
- [[`rel_time`] [A __Duration__]]
- [[`b`] [A bool]]
- [[`v`] [`act_traits<typeof(act)>::move_dest_type`]]
-]
-
-[heading Expression requirements]
-
-A type models an __FutureBasedACT__ if, in adition to being an __ACT__,
-the following expressions are valid:
-
-[table
- [[Expression] [Return type] [Runtime Complexity]]
- [[`v = get(act)`] [`act_traits<typeof(act)>::move_dest_type`] [Constant]]
- [[`b = is_ready(cact)`] [bool] [Constant]]
- [[`b = has_exception(cact)`] [bool] [Constant]]
- [[`b = has_value(cact)`] [bool] [Constant]]
-]
-
-[heading Expression Semantics]
-[table
- [[Expression] [Semantics]]
- [[`v = get(act)`] [Blocks until `act` contains a value and returns the stored value]]
- [[`b = is_ready(cact)`] [Is true only if `cact` holds a value or an exception ready for retrieval.]]
- [[`b = has_exception(cact)`] [Is true only if `cact` contains an exception.]]
- [[`b = has_value(cact)`] [Is true only if `cact` contains a value]]
-]
-
-[heading Expression `v=get(act)`]
-[/==========================================================================================]
-
-
-[variablelist
-[[Effects:] [Retrieves the value returned by the Nullary function.]]
-[[Sychronization:][The completion of the `act` happens before get() returns.]]
-[[Returns:] [Depending on the nature of the ACT returns a `act_traits<ACT>::move_dest_type`.]]
-[[Throws:] [the stored exception, if an exception was stored and not retrieved before.]]
-[[Postconditions:] [if `act_traits<ACT>::move_result` is `true` it is unspecified what happens when `get()` is called a second time on the same shared_joiner.]]
-[[Thread safety:][unsafe]]
-]
-
-[heading Expression `b = is_ready(cact)`]
-[/==========================================================================================]
-
-[variablelist
-[[Returns:] [true only if `cact` holds a value or an exception ready for retrieval.]]
-[[Remark:] [if `act_traits<ACT>::move_result` is true the return value could be unspecified after a call to `get(act)`.]]
-]
-
-[heading Expression `b = has_exception(cact)`]
-[/==========================================================================================]
-
-
-[variablelist
-[[Returns:] [true only if `is_ready(cact)` == true and `cact` contains an exception.]]
-]
-
-[heading Expression `b = has_value(cact)`]
-[/==========================================================================================]
-
-[variablelist
-[[Returns:] [true only if `is_ready(cact)` == true and `cact` contains a value.]]
-]
-
-[heading Models]
-
-* __unique_future__
-* __shared_future__
-* __unique_joiner__
-* __shared_joiner__
-* __tp_task__
-
-[endsect]
-
-[/=============================]
-[section:ThreadBasedACT Concept `ThreadBasedACT` ]
-[/=============================]
-
-The completion of the __ThreadBasedACT__ is undefined at this level but occurs usualy after a function finish.
-
-[heading Description]
-
-An __ThreadBasedACT__ is a __ACT__ that provides a thread like interface.
-
-[heading Notation]
-
-[variablelist
- [[`act`] [An __ACT__]]
- [[`cact`] [A const __ACT__]]
- [[`cact`] [An const __ACT__]]
- [[`f`] [A __Nullary__ function with type F]]
- [[`abs_time`] [A __system_time__]]
- [[`rel_time`] [A __Duration__]]
- [[`b`] [A bool]]
- [[`id`] [An `act_traits<__ACT__>::id_type`]]
-]
-
-[heading Expression requirements]
-A type models an __FutureBasedACT__ if, in adition to being an __ACT__,
-the following expressions are valid:
-
-[table
- [[Expression] [Return type] [Runtime Complexity]]
- [[`b = joinable(cact)`] [bool] [Constant]]
- [[`join(act)`] [void] [Constant]]
- [[`b = join_until(act, abs_time)`] [bool] [Constant]]
- [[`b = join_for(act, rel_time)`] [bool] [Constant]]
- [[`detach(act)`] [void] [Constant]]
- [[`interrupt(act)`] [void] [Constant]]
- [[`b = interruption_requested(cact)`] [bool] [Constant]]
- [[`id = get_id(cact)`] [`act_traits<__ACT__>::id_type`] [Constant]]
-]
-
-[heading Expression Semantics]
-[table
- [[Expression] [Semantics]]
- [[`b = joinable(cact)`] [true if `cact` refers to a 'thread of execution', false otherwise]]
- [[`join(act)`] [waits for the assoiated 'thread of execution' to complete]]
- [[`b = join_until(act, abs_time)`] [waits for the assoiated 'thread of execution' to complete or the time `wait_until` has been reach.]]
- [[`b = join_for(act, rel_time)`] [waits for the assoiated 'thread of execution' to complete or the specified duration `rel_time` has elapsed ]]
- [[`detach(act)`] [the associated 'thread of execution' becomes detached, and no longer has an associated one]]
- [[`interrupt(act)`] [request that the associated 'thread of execution' be interrupted the next time it enters
- one of the predefined interruption points with interruption enabled, or if it is currently blocked in a call to one of the
- predefined interruption points with interruption enabled]]
- [[`b = interruption_requested(cact)`] [true if interruption has been requested for the associated 'thread of execution', false otherwise. ]]
- [[`id = get_id(cact)`] [an instance of `act_traits<__ACT__>::id_type` that represents the associated 'thread of execution'.]]
-]
-
-[heading Expresion `b=joinable(act)`]
-[/==========================================================================================]
-
-[variablelist
-[[Returns:] [true if `act` refers to a 'thread of execution', false otherwise]]
-[[Throws:] [Nothing]]
-]
-
-
-[heading Expresion `join()`]
-[/==========================================================================================]
-
-[variablelist
-[[Preconditions:] [`get_id(act)!=boost::interthreads::get_current_id<ACT>()`]]
-[[Effects:] [If `act` refers to a thread of execution, waits for that 'thread of execution' to complete.]]
-[[Postconditions:] [If `act` refers to a 'thread of execution' on entry, that 'thread of execution' has completed.
-`act` no longer refers to any 'thread of execution'.]]
-[[Throws:] [__thread_interrupted__ if the current thread of execution is interrupted.]]
-[[Notes:] [`join()` is one of the predefined __interruption_points__.]]
-]
-
-[heading Expresion `b=join_until(act)|b=join_for(act)`]
-[/==========================================================================================]
-
- bool join_until(const system_time& wait_until);
-
- template<typename TimeDuration>
- bool join_for(TimeDuration const& rel_time);
-
-[variablelist
-[[Preconditions:] [`get_id(act)!=boost::interthreads::get_current_id<ACT>()`]]
-[[Effects:] [If `act` refers to a 'thread of execution', waits for that thread of execution to complete, the time `wait_until` has
-been reach or the specified duration `rel_time` has elapsed. If `act` doesn't refer to a 'thread of execution', returns immediately.]]
-[[Returns:] [`true` if `act` refers to a thread of execution on entry, and that thread of execution has completed before the call
-times out, `false` otherwise.]]
-[[Postconditions:] [If `act` refers to a thread of execution on entry, and `timed_join` returns `true`, that thread of execution
-has completed, and `act` no longer refers to any thread of execution. If this call to `timed_join` returns `false`, `*this` is
-unchanged.]]
-[[Throws:] [__thread_interrupted__ if the current thread of execution is interrupted.]]
-[[Notes:] [`join_until()` is one of the predefined __interruption_points__.]]
-]
-
-[heading Expresion `detach(act)`]
-[/==========================================================================================]
-
-[variablelist
-[[Effects:] [If `act` refers to a 'thread of execution', that 'thread of execution' becomes detached, and no longer has an associated thread object.]]
-[[Postconditions:] [`act` no longer refers to any 'thread of execution'.]]
-[[Throws:] [Nothing]]
-]
-
-[heading Expresion `get_id(cact)`]
-[/==========================================================================================]
-
-
-[variablelist
-[[Returns:] [If `act` refers to a 'thread of execution', an instance of `act_traits<__ACT__>::id_type` that represents that __ACT__.
-Otherwise returns a default-constructed `act_traits<__ACT__>::id_type`.]]
-[[Throws:] [Nothing]]
-]
-
-[heading Expresion `interrupt(act)`]
-[/==========================================================================================]
-
-
-[variablelist
-[[Effects:] [If `act` refers to a 'thread of execution', request that the 'thread of execution' will be interrupted the next time it enters one of
-the predefined __interruption_points__ with interruption enabled, or if it is currently __blocked__ in a call to one of the
-predefined __interruption_points__ with interruption enabled .]]
-[[Throws:] [Nothing]]
-]
-
-[heading Expresion `h = native_handle(act)`]
-[/==========================================================================================]
-
-
-[variablelist
-[[Effects:] [Returns an instance of `native_handle_type` that can be used with platform-specific APIs to manipulate the underlying
-implementation. If no such instance exists, `native_handle()` and `native_handle_type` are not present.]]
-[[Throws:] [Nothing.]]
-]
-
-
-
-[heading Models]
-
-* __unique_joiner__
-* __shared_joiner__
-* __thread__
-* __tp_task__
-
-[endsect]
-
-[endsect]
-
-[/======================================]
-[section Asynchronous Executors Concepts]
-[/======================================]
-
-[/==========================================================================================]
-[section Concept `AsynchronousExecutor`]
-[/==========================================================================================]
-
-[heading Description]
-
-An __AsynchronousExecutor__ executes asynchronously a function and returns an __ACT__ when calling the fork function on it.
-
-[heading Notation]
-
-[variablelist
- [[`ae`] [An __AE__]]
- [[`f`] [A __Nullary__ function with type F]]
- [[`act`] [An __ACT__]]
-]
-
-[heading Expression requirements]
-A type models a __AE__ if, the following expressions are valid:
-
-[table
- [[Expression] [Return type] [Runtime Complexity]]
- [[`__fork__(ae, f)`] [__ACT__] [Constant]]
- [[`get_future<AE>()(act)`] [__Future__] [Constant]]
- [[`asynchronous_completion_token<AE, T>::type`] [Model of __ACT__ satisfying `__act_value<ACT>::type` is `T`] [Constant]]
-]
-
-[heading Expression Semantics]
-[
-table
- [[Expression] [Semantics]]
- [[`act = __fork__(ae, f)`] [request `ae` to execute asynchronously the function `f`and returns an __ACT__ ]]
- [[`get_future<AE>()(act)`] [gets a reference to a __Future__]]
-]
-
-[heading Constraints]
-The following constraints applies:
-
-* `act_value<__ACT__>::type == boost::result_of<F()::type>`
-
-[heading Models]
-
-* __basic_threader__
-* __unique_threader__
-* __shared_threader__
-* __launcher__
-* __shared_launcher__
-* __scheduler__
-* __tp_pool__
-
-
-[endsect]
-
-
-[/==========================================================================================]
-[section Concept `IntrinsicAsynchronousExecutor`]
-[/==========================================================================================]
-
-[heading Description]
-
-The default fork implementation put some requirements in its __AE__ parameter. This concept is related to this.
-An __IAE__ is __AE__ that works well with the default implementation of __fork__.
-
-[heading Notation]
-
-[variablelist
- [[`ae`] [An __IAE__]]
- [[`f`] [A __Nullary__ function]]
-]
-
-[heading Expression requirements]
-A type models an __IAE__ if, in adition to being an __AE__,
-the following expressions are valid:
-
-[table
- [[Expression] [Return type] [Runtime Complexity]]
- [[`ae.fork(f)`] [`handle<boost::result_of<F()>::type`] [Constant]]
-]
-
-[heading Meta Expressions]
-[table
- [[Expression] [Model Of] [Compile Time Complexity]]
- [[`handle<boost::result_of<F()>::type`] [__ACT__] [Constant ]]
-]
-
-[heading Expression Semantics]
-[
-table
- [[Expression] [Semantics]]
- [[`ae.fork(f)`] [executes asynchronously the function `f` and returns a __handle__ ]]
-]
-
-
-[heading Models]
-* __basic_threader__
-* __unique_threader__
-* __shared_threader__
-* __launcher__
-* __shared_launcher__
-* __scheduler__
-
-
-
-[endsect]
-
-[endsect]

[endsect]

Modified: sandbox/interthreads/libs/interthreads/doc/getting_started.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/getting_started.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/getting_started.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -55,14 +55,6 @@
Bye, Bye!
]

-[/
-
- int main() {
- bith::wait_for_all(basic_threader_decorator, my_thread);
- return 0;
- }
-
-]

[endsect]

@@ -193,52 +185,6 @@

[endsect]

-[/==========================]
-[section Multiple algorithms]
-[/==========================]
-
-This example shows how to launch several algorithms and wait only for the more efficient.
-
- #include <boost/interthreads/typeof/threader.hpp>
- #include <boost/interthreads/wait_for_any.hpp>
- #include <iostream>
-
- namespace bith = boost::interthreads;
-
- int my_thread1() {
- sleep(3);
- std::cout << "1 thread_id=" << boost::this_thread::get_id() << std::endl;
- }
-
- int my_thread2() {
- sleep(1);
- std::cout << "2 thread_id=" << boost::this_thread::get_id() << std::endl;
- }
-
- int my_thread3() {
- sleep(2);
- std::cout << "3 thread_id=" << boost::this_thread::get_id() << std::endl;
- }
-
- int main() {
- bith::shared_threader ae;
- BOOST_AUTO(res,bith::wait_for_any(ae, my_thread1, my_thread2, my_thread3));
- std::cout << "Algotithm " << result.first+1 << " finished the first. result=" << result.second << std::endl;
- return 0;
- }
-
-This results on the following output
-
-[pre
-3 thread_id=0x9c03f8
-2 thread_id=0x9c0850
-1 thread_id=0x9d0c40
-Algotithm 2 finished the first. result=0
-
-]
-
-
-[endsect]

[endsect]

Added: sandbox/interthreads/libs/interthreads/doc/html/index.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/index.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,106 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Toward Boost.InterThreads</title>
+<link rel="stylesheet" href="../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="index.html" title="Toward Boost.InterThreads">
+<link rel="next" href="toward_boost_interthreads/overview.html" title=" Overview">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="toward_boost_interthreads/overview.html"><img src="../../../../doc/html/images/next.png" alt="Next"></a></div>
+<div class="article" lang="en">
+<div class="titlepage">
+<div>
+<div><h2 class="title">
+<a name="toward_boost_interthreads"></a>Toward Boost.InterThreads</h2></div>
+<div><div class="authorgroup"><div class="author"><h3 class="author">
+Vicente J. Botet Escriba
+</h3></div></div></div>
+<div>Copyright © 2008 -2009 Vicente J. Botet Escriba</div>
+<div><div class="legalnotice">
+<a name="id4803231"></a>
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></div>
+</div>
+<hr>
+</div>
+<div class="toc">
+Table of Contents
+<dl>
+<dt> Overview</dt>
+<dd><dl><dt> Motivation</dt></dl></dd>
+<dt> Users'Guide</dt>
+<dd><dl>
+<dt><a href="toward_boost_interthreads/users_guide/getting_started.html">
+ Getting Started</a></dt>
+<dt> Tutorial</dt>
+<dt><a href="toward_boost_interthreads/users_guide/bibliography.html">
+ References</a></dt>
+<dt> Glossary</dt>
+</dl></dd>
+<dt> Reference</dt>
+<dd><dl>
+<dt>Concepts</dt>
+<dt><a href="toward_boost_interthreads/reference/thread_extensions_reference.html">Thread
+ Extensions Reference</a></dt>
+<dt><a href="toward_boost_interthreads/reference/thread_array_reference.html">Thread
+ Array Reference</a></dt>
+</dl></dd>
+<dt>Examples</dt>
+<dd><dl>
+<dt><a href="toward_boost_interthreads/examples/thread_safe_deferred_traces.html">Thread
+ safe deferred traces</a></dt>
+<dt> STM</dt>
+</dl></dd>
+<dt>Appendices</dt>
+<dd><dl>
+<dt><a href="toward_boost_interthreads/appendices/changes.html"> Appendix
+ A: History</a></dt>
+<dt><a href="toward_boost_interthreads/appendices/rationale.html"> Appendix
+ B: Rationale</a></dt>
+<dt><a href="toward_boost_interthreads/appendices/implementation.html">
+ Appendix C: Implementation Notes</a></dt>
+<dt><a href="toward_boost_interthreads/appendices/acknowledgements.html">
+ Appendix D: Acknowledgments</a></dt>
+<dt><a href="toward_boost_interthreads/appendices/tests.html"> Appendix
+ E: Tests</a></dt>
+<dt><a href="toward_boost_interthreads/appendices/tickets.html"> Appendix
+ F: Tickets</a></dt>
+<dt><a href="toward_boost_interthreads/appendices/todo.html"> Appendix
+ G: Future plans</a></dt>
+</dl></dd>
+</dl>
+</div>
+<div class="warning"><table border="0" summary="Warning">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../doc/html/images/warning.png"></td>
+<th align="left">Warning</th>
+</tr>
+<tr><td align="left" valign="top">
+ Toward Boost.InterThreads is not a part of the Boost libraries.
+ </td></tr>
+</table></div>
+
+ [/
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left">Last revised: October 05, 2009 at 16:58:26 GMT</td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav"><a accesskey="n" href="toward_boost_interthreads/overview.html"><img src="../../../../doc/html/images/next.png" alt="Next"></a></div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/standalone_HTML.manifest
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/standalone_HTML.manifest 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,23 @@
+index.html
+toward_boost_interthreads/overview.html
+toward_boost_interthreads/overview/motivation.html
+toward_boost_interthreads/users_guide.html
+toward_boost_interthreads/users_guide/getting_started.html
+toward_boost_interthreads/users_guide/tutorial.html
+toward_boost_interthreads/users_guide/bibliography.html
+toward_boost_interthreads/users_guide/glosary.html
+toward_boost_interthreads/reference.html
+toward_boost_interthreads/reference/concepts.html
+toward_boost_interthreads/reference/thread_extensions_reference.html
+toward_boost_interthreads/reference/thread_array_reference.html
+toward_boost_interthreads/examples.html
+toward_boost_interthreads/examples/thread_safe_deferred_traces.html
+toward_boost_interthreads/examples/stm.html
+toward_boost_interthreads/appendices.html
+toward_boost_interthreads/appendices/changes.html
+toward_boost_interthreads/appendices/rationale.html
+toward_boost_interthreads/appendices/implementation.html
+toward_boost_interthreads/appendices/acknowledgements.html
+toward_boost_interthreads/appendices/tests.html
+toward_boost_interthreads/appendices/tickets.html
+toward_boost_interthreads/appendices/todo.html

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,97 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Appendices</title>
+<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../index.html" title="Toward Boost.InterThreads">
+<link rel="prev" href="examples/stm.html" title=" STM">
+<link rel="next" href="appendices/changes.html" title=" Appendix
+ A: History">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="examples/stm.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="appendices/changes.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="toward_boost_interthreads.appendices"></a>Appendices
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><a href="appendices/changes.html"> Appendix
+ A: History</a></dt>
+<dd><dl>
+<dt><a href="appendices/changes.html#toward_boost_interthreads.appendices.changes.__version_0_1_3__mars_29__2009__extraction_of_the_asynchonous_executor_framework">Version 0.1.3, Mars 29, 2009 Extraction of the Asynchonous
+ Executor framework</a></dt>
+<dt>Version 0.1.2, February 8, 2009 Bug fixes</dt>
+<dt><a href="appendices/changes.html#toward_boost_interthreads.appendices.changes.__version_0_1_1__january_14__2009__bug_fixes_and_test_on_more_toolsets">Version 0.1.1, January 14, 2009 Bug fixes and test
+ on more toolsets</a></dt>
+<dt><a href="appendices/changes.html#toward_boost_interthreads.appendices.changes.__version_0_1_0__november_30__2008____announcement_of_interthreads_">Version 0.1.0, November 30, 2008 Announcement
+ of Interthreads</a></dt>
+<dt>Bugs</dt>
+</dl></dd>
+<dt><a href="appendices/rationale.html"> Appendix
+ B: Rationale</a></dt>
+<dd><dl>
+<dt><a href="appendices/rationale.html#toward_boost_interthreads.appendices.rationale.thread_decorator">Thread
+ Decorator</a></dt>
+<dt><a href="appendices/rationale.html#toward_boost_interthreads.appendices.rationale.thread_specific_storage">Thread
+ Specific Storage</a></dt>
+<dt><a href="appendices/rationale.html#toward_boost_interthreads.appendices.rationale.keep_alive">Keep
+ Alive</a></dt>
+<dt><a href="appendices/rationale.html#toward_boost_interthreads.appendices.rationale.thread_tuple">Thread
+ Tuple</a></dt>
+</dl></dd>
+<dt><a href="appendices/implementation.html">
+ Appendix C: Implementation Notes</a></dt>
+<dd><dl>
+<dt><a href="appendices/implementation.html#toward_boost_interthreads.appendices.implementation.thread_decorator">Thread
+ Decorator</a></dt>
+<dt><a href="appendices/implementation.html#toward_boost_interthreads.appendices.implementation.thread_specific_storage">Thread
+ Specific Storage</a></dt>
+<dt><a href="appendices/implementation.html#toward_boost_interthreads.appendices.implementation.keep_alive">Keep
+ Alive</a></dt>
+<dt><a href="appendices/implementation.html#toward_boost_interthreads.appendices.implementation.thread_tuple">Thread
+ Tuple</a></dt>
+</dl></dd>
+<dt><a href="appendices/acknowledgements.html">
+ Appendix D: Acknowledgments</a></dt>
+<dt><a href="appendices/tests.html"> Appendix
+ E: Tests</a></dt>
+<dd><dl><dt>thread_specific_shared_pointer</dt></dl></dd>
+<dt><a href="appendices/tickets.html"> Appendix
+ F: Tickets</a></dt>
+<dt><a href="appendices/todo.html"> Appendix
+ G: Future plans</a></dt>
+<dd><dl>
+<dt><a href="appendices/todo.html#toward_boost_interthreads.appendices.todo.tasks_to_do_before_review">Tasks
+ to do before review</a></dt>
+<dt><a href="appendices/todo.html#toward_boost_interthreads.appendices.todo.for_later_releases">For
+ later releases</a></dt>
+</dl></dd>
+</dl></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="examples/stm.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="appendices/changes.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/acknowledgements.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/acknowledgements.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,61 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>
+ Appendix D: Acknowledgments</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../appendices.html" title="Appendices">
+<link rel="prev" href="implementation.html" title="
+ Appendix C: Implementation Notes">
+<link rel="next" href="tests.html" title=" Appendix
+ E: Tests">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="implementation.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tests.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.appendices.acknowledgements"></a><a href="acknowledgements.html" title="
+ Appendix D: Acknowledgments">
+ Appendix D: Acknowledgments</a>
+</h3></div></div></div>
+
+ Part of this library (thread_decorator and thread_specific_shared_ptr) are
+ based on the original implementation of threadalert written by Roland Schwarz (thread::init
+ and thread_member_ptr). Many Thanks to Roland that allowed me to adapt his
+ implementation.
+ 
+
+ Thanks also must go to Jochen Heckl for the ideas given respect to the thread_tuple::wait_first
+ implementation.
+ 
+
+ You can help me to make this library better! Any feedback is very welcome.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="implementation.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tests.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/changes.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/changes.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,180 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Appendix
+ A: History</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../appendices.html" title="Appendices">
+<link rel="prev" href="../appendices.html" title="Appendices">
+<link rel="next" href="rationale.html" title=" Appendix
+ B: Rationale">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../appendices.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="rationale.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.appendices.changes"></a><a href="changes.html" title=" Appendix
+ A: History"> Appendix
+ A: History</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="changes.html#toward_boost_interthreads.appendices.changes.__version_0_1_3__mars_29__2009__extraction_of_the_asynchonous_executor_framework">Version 0.1.3, Mars 29, 2009 Extraction of the Asynchonous
+ Executor framework</a></dt>
+<dt>Version 0.1.2, February 8, 2009 Bug fixes</dt>
+<dt><a href="changes.html#toward_boost_interthreads.appendices.changes.__version_0_1_1__january_14__2009__bug_fixes_and_test_on_more_toolsets">Version 0.1.1, January 14, 2009 Bug fixes and test
+ on more toolsets</a></dt>
+<dt><a href="changes.html#toward_boost_interthreads.appendices.changes.__version_0_1_0__november_30__2008____announcement_of_interthreads_">Version 0.1.0, November 30, 2008 Announcement
+ of Interthreads</a></dt>
+<dt>Bugs</dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.changes.__version_0_1_3__mars_29__2009__extraction_of_the_asynchonous_executor_framework"></a><a href="changes.html#toward_boost_interthreads.appendices.changes.__version_0_1_3__mars_29__2009__extraction_of_the_asynchonous_executor_framework" title="Version 0.1.3, Mars 29, 2009 Extraction of the Asynchonous
+ Executor framework">Version 0.1.3, Mars 29, 2009 Extraction of the Asynchonous
+ Executor framework</a>
+</h4></div></div></div>
+
+ New Features:
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ Extraction of the Asynchonous Executor framework
+ </li></ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.changes.__version_0_1_2__february_8__2009__bug_fixes"></a>Version 0.1.2, February 8, 2009 Bug fixes
+</h4></div></div></div>
+
+ Fixed Bugs:
+ 
+
+ v0.3.1#1: keep alive mechanism crash when setting
+ <code class="computeroutput">set_on_dead_thread()</code>
+ before enabling the mechanism. This was due to the fact that
+ there were no default data for the backup.
+ 
+
+ v0.3.1#2: keep alive mechanism do not detect dead
+ threads. We need to reset the counters only when the period
+ is 0.
+ 
+
+ v0.3.1#3: The <code class="computeroutput">set_on_dead_thread()</code> setting is not recovered by embeeding
+ kep_alive enablers/disablers. The problem is that the <code class="computeroutput">on_dead()</code>
+ the function and the thread pointer were stored on the backup. It is enough
+ to store them on the <code class="computeroutput">thread_keep_alive_ctx</code>
+ and make the functions thread_safe.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.changes.__version_0_1_1__january_14__2009__bug_fixes_and_test_on_more_toolsets"></a><a href="changes.html#toward_boost_interthreads.appendices.changes.__version_0_1_1__january_14__2009__bug_fixes_and_test_on_more_toolsets" title="Version 0.1.1, January 14, 2009 Bug fixes and test
+ on more toolsets">Version 0.1.1, January 14, 2009 Bug fixes and test
+ on more toolsets</a>
+</h4></div></div></div>
+
+ Toolsets:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Tested on Linux gcc 3.4.6.
+ </li>
+<li>
+ Tested on Linux gcc 4.1.2.
+ </li>
+<li>
+ Modification helping Windows (not tested)
+ </li>
+</ul></div>
+
+ Fixed Bugs:
+ 
+
+ v0.1#1: basic_keep_alive example do not link.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.changes.__version_0_1_0__november_30__2008____announcement_of_interthreads_"></a><a href="changes.html#toward_boost_interthreads.appendices.changes.__version_0_1_0__november_30__2008____announcement_of_interthreads_" title="Version 0.1.0, November 30, 2008 Announcement
+ of Interthreads">Version 0.1.0, November 30, 2008 Announcement
+ of Interthreads</a>
+</h4></div></div></div>
+
+ Features:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput">thread_decorator</code> setup/cleanup
+ thread decorator,
+ </li>
+<li>
+ thread specific shared pointer,
+ </li>
+<li>
+ thread keep alive mechanism,
+ </li>
+<li>
+ thread tuples, set_once synchonizer, thread_tuple_once and thread_group_once.
+ </li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.changes.__bugs_"></a>Bugs
+</h4></div></div></div>
+<a name="toward_boost_interthreads.appendices.changes.__bugs_._emphasis_role__bold__open_bugs___emphasis_"></a><h5>
+<a name="id4854878"></a>
+ Open Bugs:
+ </h5>
+<a name="toward_boost_interthreads.appendices.changes.__bugs_._emphasis_role__bold__fixed_bugs___emphasis_"></a><h5>
+<a name="id4854907"></a>
+ Fixed Bugs:
+ </h5>
+
+ v0.1.1#1: keep alive mechanism crash when setting
+ set_on_dead_thread before enabling the mechanism. This was due
+ to the fact that there were no default data for the backup.
+ 
+
+ v0.1.1#2: keep alive mechanism do not detect dead
+ threads. We need to reste the counters only when the period
+ is 0.
+ 
+
+ v0.1.1#3: The set_on_dead_thread setting is not recovered
+ by embeeding enablers/disablers. The problem is that the on_dead
+ and th thread pointer were stored on the backup. It is enough to store
+ them on the
+ 
+
+ v0.1#1: basic_keep_alive example do not link.
+ 
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../appendices.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="rationale.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/implementation.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/implementation.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,196 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>
+ Appendix C: Implementation Notes</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../appendices.html" title="Appendices">
+<link rel="prev" href="rationale.html" title=" Appendix
+ B: Rationale">
+<link rel="next" href="acknowledgements.html" title="
+ Appendix D: Acknowledgments">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="rationale.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgements.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.appendices.implementation"></a><a href="implementation.html" title="
+ Appendix C: Implementation Notes">
+ Appendix C: Implementation Notes</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="implementation.html#toward_boost_interthreads.appendices.implementation.thread_decorator">Thread
+ Decorator</a></dt>
+<dt><a href="implementation.html#toward_boost_interthreads.appendices.implementation.thread_specific_storage">Thread
+ Specific Storage</a></dt>
+<dt><a href="implementation.html#toward_boost_interthreads.appendices.implementation.keep_alive">Keep
+ Alive</a></dt>
+<dt><a href="implementation.html#toward_boost_interthreads.appendices.implementation.thread_tuple">Thread
+ Tuple</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.implementation.thread_decorator"></a><a href="implementation.html#toward_boost_interthreads.appendices.implementation.thread_decorator" title="Thread
+ Decorator">Thread
+ Decorator</a>
+</h4></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt>Thread safe</dt>
+<dd>
+ The library is thread safe as far as the thread decorations are declared
+ staticaly, because these variables will be initialized sequentially.
+ </dd>
+<dt>Chained thread decorations</dt>
+<dd>
+ All the thread decorations are chained between them.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.implementation.thread_specific_storage"></a><a href="implementation.html#toward_boost_interthreads.appendices.implementation.thread_specific_storage" title="Thread
+ Specific Storage">Thread
+ Specific Storage</a>
+</h4></div></div></div>
+
+ The Thread-Specific Storage pattern can be implemented in various ways
+ 
+<div class="variablelist">
+
+<dl>
+<dt>External versus internal thread storage</dt>
+<dd>
+ The thread specific data collections can be stored either externally
+ to all threads or internally to each thread. The thread_specific_shared_ptr
+ use both ensuring efficiency when the context is requested by the current
+ thread and allowing threads to access thread specific pointer of other
+ threads
+ </dd>
+<dt>Fixed- vs. variable-sized thread specific
+ key mapping</dt>
+<dd>
+ This library is based on the the Boost.Thread thread_specific_ptr implementation
+ which use a variable-size map indexed by the address of the object.
+ Future releases will provide fixed and mixed keys.
+ </dd>
+<dt>Fixed- vs. variable-sized mapping of
+ thread IDs to thread specific pointers</dt>
+<dd>
+ It may be impractical to have a fixed-size array with an entry for
+ every possible thread ID value. Instead, it is more space efficient
+ to have threads use a dynamic data structure to map thread IDs to thread
+ specific pointers.
+ </dd>
+<dt>One mapping of thread IDs to thread
+ specific pointers or to thread specific key mapping</dt>
+<dd>
+ This library maps thread IDs to thread specific pointers to avoid contention
+ on a single map.
+ </dd>
+<dt>Default versus explicit specific context
+ setting</dt>
+<dd>
+ This library provides explicit setting. In future release will provide
+ explicit/eager and implicit/lazy specific context setting. Note that
+ implicit setting will need a factory or a default constructible type.
+ </dd>
+<dt>Ordered or unordered map</dt>
+<dd>
+ While the thread::id type is ordered, there is no need to use it. The
+ current implementation use an ordered map. Future version will allow
+ the user to configure this.
+ </dd>
+<dt>Intrusive or not maps</dt>
+<dd>
+ As the thread specific pointer is stored on only one map the implementation
+ could use an intrusive container. This will be provided in future releases
+ </dd>
+<dt>Shared versus exclusive locking</dt>
+<dd>
+ Locating the right TS pointer requires the use of mutex to prevent
+ race conditions. The library use a a shared_mutex because most of the
+ access to the map will be readings by other threads. The problem is
+ that the native conditions can not be used directly with shared mutex.
+ Some benchmarks will be needed before decidinf which implementation
+ is the best.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.implementation.keep_alive"></a><a href="implementation.html#toward_boost_interthreads.appendices.implementation.keep_alive" title="Keep
+ Alive">Keep
+ Alive</a>
+</h4></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt>Ensuring keep alive manager singleton
+ is initialized and the thread specific shared storage is set before use</dt>
+<dd>
+ The use of the thread decoration ensures that the decoration are called
+ before the user thread function is called. The keep_alive decoration
+ use the call_once to ensure that the keep_alive manager is correctly
+ initialized.
+ </dd>
+<dt>backup/restore context</dt>
+<dd>
+ The real thread specific data is stored directly on the stack of enablers/disablers
+ avoiding heap memory. On enablers/disablers construction they store
+ a backup pointer to the nesting context. This allows a quick restore.
+ The keep alive pointer contains just a pointer to this data.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.implementation.thread_tuple"></a><a href="implementation.html#toward_boost_interthreads.appendices.implementation.thread_tuple" title="Thread
+ Tuple">Thread
+ Tuple</a>
+</h4></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt>Joining the first finishing thread</dt>
+<dd>
+ In order to synchronize the end of all the threads the libarry use
+ a internal class which stores the index of the first thread notifying
+ that it is finished. As the user function has no idea of this index
+ we need to wrap the user thread functions.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="rationale.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="acknowledgements.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/rationale.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/rationale.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,1136 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Appendix
+ B: Rationale</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../appendices.html" title="Appendices">
+<link rel="prev" href="changes.html" title=" Appendix
+ A: History">
+<link rel="next" href="implementation.html" title="
+ Appendix C: Implementation Notes">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="changes.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="implementation.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.appendices.rationale"></a><a href="rationale.html" title=" Appendix
+ B: Rationale"> Appendix
+ B: Rationale</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="rationale.html#toward_boost_interthreads.appendices.rationale.thread_decorator">Thread
+ Decorator</a></dt>
+<dt><a href="rationale.html#toward_boost_interthreads.appendices.rationale.thread_specific_storage">Thread
+ Specific Storage</a></dt>
+<dt><a href="rationale.html#toward_boost_interthreads.appendices.rationale.keep_alive">Keep
+ Alive</a></dt>
+<dt><a href="rationale.html#toward_boost_interthreads.appendices.rationale.thread_tuple">Thread
+ Tuple</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.rationale.thread_decorator"></a><a href="rationale.html#toward_boost_interthreads.appendices.rationale.thread_decorator" title="Thread
+ Decorator">Thread
+ Decorator</a>
+</h4></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt>Function wrapper versus thread refinement</dt>
+<dd>
+ The threadalert on which this library was initialy based redefined
+ the boost:thread class which called implicitly the wrapper. As the
+ single varying features between both threads was this wrapping of the
+ thread function it has been isolated in the interthreads library.
+ </dd>
+<dt>Static decoration variables</dt>
+<dd>
+ Thread decorations construction is not thread safe and must be done
+ before other threads have been created and the <code class="computeroutput">decorate()</code> function is called.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.rationale.thread_specific_storage"></a><a href="rationale.html#toward_boost_interthreads.appendices.rationale.thread_specific_storage" title="Thread
+ Specific Storage">Thread
+ Specific Storage</a>
+</h4></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt>Non copiable/Non movable</dt>
+<dd>
+ Specific pointers are singletons.
+ </dd>
+<dt>External locking</dt>
+<dd>
+ In order to ensure thread safety while providing as much functionality
+ as possible the class allows to get the map of thread specific contexts
+ as soon as the application provides a <code class="computeroutput">unique_lock</code>.
+ </dd>
+<dt>Mimic thread_specific_ptr</dt>
+<dd>
+
+ From the point of view of the current thread thread_specific_shared_ptr
+ behaves as a thread_specific_ptr. From it we takes:
+ 
+
+
+
+<pre class="programlisting">thread_specific_shared_ptr();
+explicit thread_specific_shared_ptr(void (*cleanup_)(shared_ptr_type));
+T* get() const;
+T* operator->() const;
+T& operator*() const;
+void reset();
+template<class Y> void reset(Y * p);
+</pre>
+
+ 
+</dd>
+<dt>Mimic shared_ptr</dt>
+<dd>
+
+ From the point of view of the other threads thread_specific_shared_ptr
+ behaves as a shared_ptr lockup. From the point of view of the current
+ thread the stored pointer is located in a shared_pointer, so we can
+ use the shared_ptr deleter feature From shared_ptr takes:
+ 
+
+
+
+<pre class="programlisting">T* get() const;
+T* operator->() const;
+T& operator*() const;
+void reset();
+template<class Y> void reset(Y * p);
+template<class Y, class D> void reset(Y * p, D d);
+template<class Y, class D, class A> void reset(Y * p, D d, A a);
+</pre>
+
+ 
+</dd>
+<dt>Why doesn't thread_specific_shared_ptr
+ provide a release() function?</dt>
+<dd>
+ As it store a shared_ptr, it cannot give away ownership unless it's
+ unique() because the other copy will still destroy the object.
+ </dd>
+</dl>
+</div>
+<a name="toward_boost_interthreads.appendices.rationale.thread_specific_storage.comparaing_tsss_and_tss"></a><h5>
+<a name="id4855813"></a>
+ <a href="rationale.html#toward_boost_interthreads.appendices.rationale.thread_specific_storage.comparaing_tsss_and_tss">Comparaing
+ TSSS and TSS</a>
+ </h5>
+<div class="table">
+<a name="id4855829"></a>Table 1. Comparaing TSSS and TSS
+<table class="table" summary="Comparaing TSSS and TSS">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Feature
+ 
+ </th>
+<th>
+ 
+ thread_specific_shared_ptr
+ 
+ </th>
+<th>
+ 
+ thread_specific_ptr
+ 
+ </th>
+<th>
+ 
+ Compatible
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ ownership
+ 
+ </td>
+<td>
+ 
+ shared
+ 
+ </td>
+<td>
+ 
+ exclusive
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ default constructor
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ cleanup constructor
+ 
+ </td>
+<td>
+ 
+ yes: can not delete the pointer
+ 
+ </td>
+<td>
+ 
+ yes:must delete the pointer
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">get()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">operator->()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">operator*()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">reset()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">reset(T*)</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">reset(Y*)</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">reset(Y*,D)</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">reset(Y*,D,A)</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">release()</code>
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">get_mutex()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">get_map()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">operator[]()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">wait_and_get()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+</tbody>
+</table>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.rationale.keep_alive"></a><a href="rationale.html#toward_boost_interthreads.appendices.rationale.keep_alive" title="Keep
+ Alive">Keep
+ Alive</a>
+</h4></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt>Can a thread that has just do a check
+ point be considered as dead less than one second after?</dt>
+<dd>
+ Whell this depends on the enabling parameters. If the checking parameter
+ is greater than one it could be possible that the thread do a check_point
+ just before the keep alive manager do the check, seen that there are
+ not enough check_points and declaring the thread dead. If you want
+ to avoid this situation let the checkin to 1.
+ </dd>
+<dt>Nesting enablers and disablers</dt>
+<dd>
+ Enablers/disablers use RAII, so they can be nested and the context
+ be restored on the destructor.
+ </dd>
+<dt>Configurable on dead action</dt>
+<dd>
+ The default action is to abort the process because I don't see any
+ generic and cleaner way to manage this event. The library provides
+ this hook for user wanting to try something specific.
+ </dd>
+<dt>Who control the controler?</dt>
+<dd>
+ There is no way to control this thread other than adding an external
+ process.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.rationale.thread_tuple"></a><a href="rationale.html#toward_boost_interthreads.appendices.rationale.thread_tuple" title="Thread
+ Tuple">Thread
+ Tuple</a>
+</h4></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt>Why must be not copiable?</dt>
+<dd>
+ Thread tuples can not be copiable since boost::thread is not copiable.
+ </dd>
+<dt>Why should be movable?</dt>
+<dd>
+ If we want functions to return Thread tuples it is necessary to make
+ them movable.
+ </dd>
+<dt>Mimic boost::thread_group</dt>
+<dd>
+
+ thread_tuple has in common some function found in thread_group. From
+ it we take
+ 
+
+
+
+<pre class="programlisting">void join_all();
+void interrupt_all();
+std::size_t size();
+</pre>
+
+ 
+
+ 
+</dd>
+<dt>Mimic boost::thread</dt>
+<dd>
+
+ We can consider a thread tuple as a compound thread, and so we can
+ mimic the thread intyerface. From it we takes
+ 
+
+
+
+<pre class="programlisting">void join();
+void interrupt();
+void detach/detach_all();
+bool interruption_requested() const;
+void timed_join/timed_join_all();
+bool joinable/all_joinable() const;
+</pre>
+
+ 
+
+ 
+</dd>
+<dt>Why the user can not modify directly
+ the embeeded threads?</dt>
+<dd>
+
+ 
+
+ The library provides a safe function to get a constant thread reference
+ 
+
+
+
+<pre class="programlisting">const thread& operator[](std::size_t i) const;</pre>
+
+ 
+
+ The problem if we provide the non constant variant is that the user
+ can detach them.
+ 
+
+ 
+</dd>
+<dt>Joining the first finishing thread
+ of a thread tuple</dt>
+<dd>
+ This functionallity has a price. We need to synchronize all the threads
+ transparently, so we need to wrap the user thread functions.
+ </dd>
+</dl>
+</div>
+<a name="toward_boost_interthreads.appendices.rationale.thread_tuple.comparaing_thread__thread_group_and_thread_tuple"></a><h5>
+<a name="id4857229"></a>
+ <a href="rationale.html#toward_boost_interthreads.appendices.rationale.thread_tuple.comparaing_thread__thread_group_and_thread_tuple">Comparaing
+ thread, thread_group and thread_tuple</a>
+ </h5>
+<div class="table">
+<a name="id4857246"></a>Table 2. Comparaing thread, thread_group and thread_tuple
+<table class="table" summary="Comparaing thread, thread_group and thread_tuple">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Feature
+ 
+ </th>
+<th>
+ 
+ thread
+ 
+ </th>
+<th>
+ 
+ thread_group
+ 
+ </th>
+<th>
+ 
+ thread_tuple
+ 
+ </th>
+<th>
+ 
+ Compatible
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ default constructor
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ copiable
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ movable
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">joinable()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no*
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">join()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no*
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">timed_join()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no*
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">interruption_requested()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no*
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">join_all()</code>
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">timed_join_all()</code>
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">interrupt_all()</code>
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">size()</code>
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no* *
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">join_first_then_interrupt()</code>
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no* * *
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">timed_join_first_then_interrupt()</code>
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no* * *
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">operator[]()</code>
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ <code class="computeroutput">swap()</code>
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no
+ 
+ </td>
+<td>
+ 
+ yes
+ 
+ </td>
+<td>
+ 
+ no*
+ 
+ </td>
+</tr>
+</tbody>
+</table>
+</div>
+<div class="variablelist">
+
+<dl>
+<dt>*</dt>
+<dd>
+ thread_group could add these synonym functions
+ </dd>
+<dt>* *</dt>
+<dd>
+ thread could add the size function returning 1
+ </dd>
+<dt>* * *</dt>
+<dd>
+ thread & thread_group could add these functions
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="changes.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="implementation.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/tests.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/tests.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,58 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Appendix
+ E: Tests</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../appendices.html" title="Appendices">
+<link rel="prev" href="acknowledgements.html" title="
+ Appendix D: Acknowledgments">
+<link rel="next" href="tickets.html" title=" Appendix
+ F: Tickets">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="acknowledgements.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tickets.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.appendices.tests"></a><a href="tests.html" title=" Appendix
+ E: Tests"> Appendix
+ E: Tests</a>
+</h3></div></div></div>
+<div class="toc"><dl><dt>thread_specific_shared_pointer</dt></dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.tests.thread_specific_shared_pointer"></a>thread_specific_shared_pointer
+</h4></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup></colgroup>
+<tbody></tbody>
+</table></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="acknowledgements.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tickets.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/tickets.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/tickets.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,286 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Appendix
+ F: Tickets</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../appendices.html" title="Appendices">
+<link rel="prev" href="tests.html" title=" Appendix
+ E: Tests">
+<link rel="next" href="todo.html" title=" Appendix
+ G: Future plans">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tests.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="todo.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.appendices.tickets"></a><a href="tickets.html" title=" Appendix
+ F: Tickets"> Appendix
+ F: Tickets</a>
+</h3></div></div></div>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+ 
+ Kind
+ 
+ </th>
+<th>
+ 
+ Identifier
+ 
+ </th>
+<th>
+ 
+ Description
+ 
+ </th>
+<th>
+ 
+ Resolution
+ 
+ </th>
+<th>
+ 
+ State
+ 
+ </th>
+<th>
+ 
+ Tests
+ 
+ </th>
+<th>
+ 
+ Version
+ 
+ </th>
+</tr></thead>
+<tbody>
+<tr>
+<td>
+ 
+ bug
+ 
+ </td>
+<td>
+ 
+ v0.1#1
+ 
+ </td>
+<td>
+ 
+ basic_keep_alive example do not link
+ 
+ </td>
+<td>
+ 
+ Add to the link
+ 
+ </td>
+<td>
+ 
+ Closed
+ 
+ </td>
+<td>
+ 
+ See basic_keep_alive.cpp example
+ 
+ </td>
+<td>
+ 
+ v0.2
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ bug
+ 
+ </td>
+<td>
+ 
+ v0.1.1#1
+ 
+ </td>
+<td>
+ 
+ keep alive mechanism crash when setting set_on_dead_thread before
+ enabling the mechanism
+ 
+ </td>
+<td>
+ 
+ This was due to the fact that there were no default data for the
+ backup.
+ 
+ </td>
+<td>
+ 
+ Closed
+ 
+ </td>
+<td>
+ 
+ See basic_keep_alive.cpp example
+ 
+ </td>
+<td>
+ 
+ v0.4
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ bug
+ 
+ </td>
+<td>
+ 
+ v0.1.1#2
+ 
+ </td>
+<td>
+ 
+ keep alive mechanism do not detect dead threads
+ 
+ </td>
+<td>
+ 
+ We need to reset the counters only when the period is 0.
+ 
+ </td>
+<td>
+ 
+ Closed
+ 
+ </td>
+<td>
+ 
+ See basic_keep_alive.cpp example
+ 
+ </td>
+<td>
+ 
+ v0.4
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ bug
+ 
+ </td>
+<td>
+ 
+ v0.1.1#3
+ 
+ </td>
+<td>
+ 
+ The set_on_dead_thread setting is not recovered by embeeding enablers/disablers
+ 
+ </td>
+<td>
+ 
+ The problem is that the on_dead and th thread pointer were stored
+ on the backup. It is enough to store them on the
+ 
+ </td>
+<td>
+ 
+ Closed
+ 
+ </td>
+<td>
+ 
+ See basic_keep_alive.cpp example
+ 
+ </td>
+<td>
+ 
+ v0.4
+ 
+ </td>
+</tr>
+<tr>
+<td>
+ 
+ bug
+ 
+ </td>
+<td>
+ 
+ v0.2.0#1
+ 
+ </td>
+<td>
+ 
+ xxx
+ 
+ </td>
+<td>
+ 
+ xx
+ 
+ </td>
+<td>
+ 
+ Open
+ 
+ </td>
+<td>
+ 
+ xxx
+ 
+ </td>
+<td>
+ 
+ v0.4.1
+ 
+ </td>
+</tr>
+</tbody>
+</table></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tests.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="todo.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/todo.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/appendices/todo.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,251 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Appendix
+ G: Future plans</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../appendices.html" title="Appendices">
+<link rel="prev" href="tickets.html" title=" Appendix
+ F: Tickets">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tickets.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.appendices.todo"></a><a href="todo.html" title=" Appendix
+ G: Future plans"> Appendix
+ G: Future plans</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="todo.html#toward_boost_interthreads.appendices.todo.tasks_to_do_before_review">Tasks
+ to do before review</a></dt>
+<dt><a href="todo.html#toward_boost_interthreads.appendices.todo.for_later_releases">For
+ later releases</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.todo.tasks_to_do_before_review"></a><a href="todo.html#toward_boost_interthreads.appendices.todo.tasks_to_do_before_review" title="Tasks
+ to do before review">Tasks
+ to do before review</a>
+</h4></div></div></div>
+<a name="toward_boost_interthreads.appendices.todo.tasks_to_do_before_review.complete_the_tests"></a><h5>
+<a name="id4858992"></a>
+ <a href="todo.html#toward_boost_interthreads.appendices.todo.tasks_to_do_before_review.complete_the_tests">Complete
+ the tests</a>
+ </h5>
+
+ Even if the current release include some test there is yet a long way before
+ been able to review the library.]]
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ change the test so they take less time using locks; conditions and variables.
+ </li>
+<li>
+ Add test with functions throwing
+ </li>
+<li>
+ Formalize the tests for thread_decoratoor
+ </li>
+<li>
+ Formalize the tests for thread_specific_shared_ptr
+ </li>
+<li>
+ Add tests for keep alive mechanism
+ </li>
+</ul></div>
+<a name="toward_boost_interthreads.appendices.todo.tasks_to_do_before_review.add_more_examples"></a><h5>
+<a name="id4859047"></a>
+ <a href="todo.html#toward_boost_interthreads.appendices.todo.tasks_to_do_before_review.add_more_examples">Add
+ more examples</a>
+ </h5>
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Complete the STM example.
+ </li>
+<li>
+ Change the implementation of the file on the async_ostream.
+ </li>
+</ul></div>
+<a name="toward_boost_interthreads.appendices.todo.tasks_to_do_before_review.change_the_rational_and_implementation_sections"></a><h5>
+<a name="id4859085"></a>
+ <a href="todo.html#toward_boost_interthreads.appendices.todo.tasks_to_do_before_review.change_the_rational_and_implementation_sections">Change
+ the rational and implementation sections</a>
+ </h5>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.appendices.todo.for_later_releases"></a><a href="todo.html#toward_boost_interthreads.appendices.todo.for_later_releases" title="For
+ later releases">For
+ later releases</a>
+</h4></div></div></div>
+<a name="toward_boost_interthreads.appendices.todo.for_later_releases.add_c__0x_move_semantics_on_compilers_supporting_it_and_use_the_boost_move_emulation_otherwise"></a><h5>
+<a name="id4859127"></a>
+ <a href="todo.html#toward_boost_interthreads.appendices.todo.for_later_releases.add_c__0x_move_semantics_on_compilers_supporting_it_and_use_the_boost_move_emulation_otherwise">Add
+ C++0x move semantics on compilers supporting it and use the Boost.Move
+ emulation otherwise</a>
+ </h5>
+<a name="toward_boost_interthreads.appendices.todo.for_later_releases.use_c__0x_variadic_templates_on_compilers_supporting_it_and_use_the_preprocesor_otherwise"></a><h5>
+<a name="id4859157"></a>
+ <a href="todo.html#toward_boost_interthreads.appendices.todo.for_later_releases.use_c__0x_variadic_templates_on_compilers_supporting_it_and_use_the_preprocesor_otherwise">Use
+ C++0x variadic templates on compilers supporting it and use the preprocesor
+ otherwise</a>
+ </h5>
+<a name="toward_boost_interthreads.appendices.todo.for_later_releases.use_c__0x_concepts_on_compilers_supporting_them_and_use_the_boost_conceptcheck_or_boost_concepttraits_otherwise"></a><h5>
+<a name="id4859188"></a>
+ <a href="todo.html#toward_boost_interthreads.appendices.todo.for_later_releases.use_c__0x_concepts_on_compilers_supporting_them_and_use_the_boost_conceptcheck_or_boost_concepttraits_otherwise">Use
+ C++0x Concepts on compilers supporting them and use the Boost.ConceptCheck
+ or Boost.ConceptTraits otherwise</a>
+ </h5>
+<a name="toward_boost_interthreads.appendices.todo.for_later_releases.add_a_daemon_controlling_all_the_keep_alive_controller_threads"></a><h5>
+<a name="id4859219"></a>
+ <a href="todo.html#toward_boost_interthreads.appendices.todo.for_later_releases.add_a_daemon_controlling_all_the_keep_alive_controller_threads">Add
+ a daemon controlling all the keep alive controller threads</a>
+ </h5>
+
+ This daemon will send regular keep_alive messages and kill the process
+ when dead.
+ 
+<a name="toward_boost_interthreads.appendices.todo.for_later_releases.optimize_the_tsss_maps_using_intrusive_containers"></a><h5>
+<a name="id4859257"></a>
+ <a href="todo.html#toward_boost_interthreads.appendices.todo.for_later_releases.optimize_the_tsss_maps_using_intrusive_containers">Optimize
+ the TSSS maps using intrusive containers</a>
+ </h5>
+<a name="toward_boost_interthreads.appendices.todo.for_later_releases.generalize_both_specific_pointers_in_a_template_class_basic_thread_specific_ptr"></a><h5>
+<a name="id4859280"></a>
+ <a href="todo.html#toward_boost_interthreads.appendices.todo.for_later_releases.generalize_both_specific_pointers_in_a_template_class_basic_thread_specific_ptr">Generalize
+ both specific pointers in a template class basic_thread_specific_ptr</a>
+ </h5>
+
+ Domain Features
+ 
+<div class="variablelist">
+
+<dl>
+<dt>ownership: exclusive/shared</dt>
+<dd>
+ Specifies if the pointer is exclusive to the thread or shared with
+ other threads.
+ </dd>
+<dt>key range: fixed/variable/mixed </dt>
+<dd>
+ Specifies how the key range is defined. fixed has an integer range
+ 0..n, variable takes as key the address of the specific_ptr and mixed
+ use a variant of fixed or variable key.
+ </dd>
+<dt>key creation: eager/lazy</dt>
+<dd>
+ Specifies how the key is created, eager at construction time, lazy
+ when needed.
+ </dd>
+<dt>context setting: eager/lazy</dt>
+<dd>
+ Specifies how the pointer is set, eager at thread initialization time,
+ lazy when needed.
+ </dd>
+</dl>
+</div>
+
+ The current <code class="computeroutput">thread_specific_ptr</code>
+ is exclusive, has a variable key range and so the key is initialized at
+ construction time and explicit context setting by user on the current thread.
+ 
+<pre class="programlisting">typedef basic_thread_specific_ptr<exclusive, variable_key_range<>, eager_context_setting> thread_specific_ptr;
+</pre>
+
+ The current <code class="computeroutput">thread_specific_shared_ptr</code>
+ is shared, has a variable key range and so the key is initialized at construction
+ time and explicit context setting by user on the current thread.
+ 
+<pre class="programlisting">typedef basic_thread_specific_ptr<exclusive, variable_key_range<>, eager_context_setting> thread_specific_ptr;
+</pre>
+
+ Design rationale
+ 
+
+ <code class="computeroutput">boost::thread_specific_ptr</code> uses as key the address
+ of the variable. This has as consequence that the mapping from keys to
+ the thread specific context pointer is much less efficient that the direct
+ access provided by some implementations. In this concern this library would
+ try to improve the performance to this mapping providing direct access
+ keys. As the number of direct access keys must be know at compile time
+ this has a limit on the number of thread specific pointers. A mixed approach
+ would be also provided in which the key could be a fixed one or a variable
+ one. It is up to the user to give an hint of the key sort. When using fixed
+ or mixed keys, there is decision to take related to when the key is created,
+ i.e. eager before the threads starts or lazy when we need it.
+ 
+
+ Non-portable: The interfaces of POSIX Pthreads, Solaris threads, and Win32
+ threads are very similar. However, the semantics of Win32 threads are subtly
+ different since they do not provide a reliable means of cleaning up objects
+ allocated in thread-specific storage when a thread exits. Moreover, there
+ is no API to delete a key in Solaris threads. This makes it hard to write
+ portable code among UNIX and Win32 platforms.
+ 
+
+ So we need to implement it on top of the underlying OS. The idea is to
+ take a native thread specific pointer which will manage with the fixed,
+ variable and mixed keys. This exactly the approach of <code class="computeroutput">boost::thread_specific_ptr</code>
+ but only for variable keys.
+ 
+
+ Just to finish, we need to decide when the context is set, two possibilities:
+ the user sets explicitlly the context when it considers pertinent or the
+ context is created lazily the first time we try to get it. The first approach
+ has the liability that the user needs to ensure that the context is set
+ before get them, but when the context must be set before the function thread
+ starts this is a no issue. The second is safe but has as consequence that
+ every access include a check. In addition the type must be default constructible.
+ 
+<pre class="programlisting">bith::thread_specific_shared_ptr<myclass, lazy_setting> ptr;
+</pre>
+
+ The pointer will be initilaized when needed as if we had do
+ 
+<pre class="programlisting">if (ptr.get()==0) {
+ ptr.reset( new myclass() );
+}
+</pre>
+
+ Between the features:
+ 
+
+ Thread_specific key mapping optimization: Replace the Boost.Thread thread_specific_ptr
+ thread specific key mapping implementation by a mix of fixed/variable mapping
+ which will provide efficient access to the fixed keys and scalability with
+ the others keys.
+ 
+
+ Configuration the fixed/variable/mixed key range, ordered/unordered map,
+ intrusive/extrusive map, shared/exclusive locking.
+ 
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tickets.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../appendices.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/examples.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/examples.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,53 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Examples</title>
+<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../index.html" title="Toward Boost.InterThreads">
+<link rel="prev" href="reference/thread_array_reference.html" title="Thread
+ Array Reference">
+<link rel="next" href="examples/thread_safe_deferred_traces.html" title="Thread
+ safe deferred traces">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="reference/thread_array_reference.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/thread_safe_deferred_traces.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="toward_boost_interthreads.examples"></a>Examples
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><a href="examples/thread_safe_deferred_traces.html">Thread
+ safe deferred traces</a></dt>
+<dt> STM</dt>
+</dl></div>
+
+ This section do includes complete examples using the library.
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="reference/thread_array_reference.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="examples/thread_safe_deferred_traces.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/examples/stm.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/examples/stm.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,357 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> STM</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../examples.html" title="Examples">
+<link rel="prev" href="thread_safe_deferred_traces.html" title="Thread
+ safe deferred traces">
+<link rel="next" href="../appendices.html" title="Appendices">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="thread_safe_deferred_traces.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../appendices.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.examples.stm"></a> STM
+</h3></div></div></div>
+
+ This section does not include a complete example using the library, but only
+ a case study that could use the library in some way. I'm curently working
+ on this.
+ 
+
+ Transactional memory (TM) is a recent parallel programming concept which
+ reduces challenges found in parallel programming. TM offers numerous advantages
+ over other synchronization mechanisms.
+ 
+
+ This case study contains some thoughts on how I see a "boostified"
+ version of DracoSTM, a software transactional memory (STM) system. DracoSTM
+ is a high performance lock-based C++ STM research library. DracoSTM uses
+ only native object-oriented language semantics, increasing its intuitiveness
+ for developers while maintaining high programmability via automatic handling
+ of composition, locks and transaction termination.
+ 
+
+ The example will show only the part concerning how the different contexts
+ are stored.
+ 
+
+ Let me start of with a typical use of this library with the Hello World!
+ of transactional concurrent programming, Bank accounts and transfers. Let
+ BankAccount be a simple account.
+ 
+<pre class="programlisting">class BankAccount {
+public:
+ void Deposit(unsigned amount);
+ void Withdraw(unsigned amount);
+ int GetBalance() const;
+};
+void Transfer(BankAccount* inA, BankAccount* outA, int amount);
+class AccountManager {
+public:
+ BankAccount* checkingAcct_;
+ BankAccount* savingsAcct_;
+ AccountManager(BankAccount& checking, BankAccount& savings)
+ : checkingAcct_(&checking)
+ , savingsAcct_(&savings)
+ {}
+ void Checking2Savings(int amount) {
+ Transfer(checkingAcct_, savingsAcct_, amount);
+ }
+};
+</pre>
+
+ And here a little programm that emulates an employer and two employees behaviors.
+ The employees have requested the employer to transfer their salaries to their
+ checking accounts every month. The employer does the transfer on the 28th
+ of each month. The employees perform withdrawals and queries from their accounts
+ using an ATM. Some people have requested the Bank for automatic periodic
+ transfers from their checking accounts to their saving accounts. The transfer
+ is done on the 3rd of each month.
+ 
+<pre class="programlisting">BankAccount *emp;
+BankAccount *c1;
+BankAccount *c2;
+BankAccount *s1;
+AccountManager *am1;
+
+int employer_th() {
+ sleep_for(day(28));
+ for (int i=0;i<2;++i) {
+ Transfer(emp, c1, 3000);
+ Transfer(emp, c2, 3200);
+ sleep(month(1));
+ }
+}
+
+void people_1_th() {
+ sleep_for(day(1));
+ c1->Withdraw(100);
+ sleep_for(day(5));
+ c1->Withdraw(500);
+ sleep_for(day(4));
+ c1->Withdraw(200);
+}
+
+void automatic_transfer_th(AccountManager *am, unsigned debit) {
+ sleep_for(day(3));
+ for (int i=0;i<2;++i) {
+ am.Checking2Savings(debit);
+ sleep_for(month(1));
+ };
+}
+</pre>
+
+ Evidently every operation must be atomic. We use the STM_ATOMIC and STM_END_ATOMIC
+ macors to hide all the transaction complexity
+ 
+<pre class="programlisting">class BankAccount {
+ int balance_;
+public:
+ void Deposit(unsigned amount) {
+ STM_ATOMIC(t) {
+ t.wr_ptr(this)->balance_ += amount;
+ } STM_END_ATOMIC
+ }
+ // ...
+
+};
+</pre>
+
+ How all this works? Let me write what what is begind these macros. These
+ macros use a trick to that ensure that when the statement between both macros
+ succeed the transaction is committed. As the transaction can fail (exception
+ transaction_aborted thrown) we need to reiterate the execution of the statement.
+ So what a user needs to write is something like
+ 
+<pre class="programlisting">void Deposit(unsigned amount) {
+ for (stm::transaction t; !t.commited() && t.restart(); t.no_throw_commit()) {
+ try {
+ t.wr_ptr(this)->balance_ += amount;
+ } catch (stm::transaction_aborted&) {}
+ }
+}
+</pre>
+
+ 1. creation of a new transaction 2.a if not commited restart the transaction
+ and enter the body of the for (3) 2.b if commited exit the for. 3. execute
+ the statement 4 catch stm::transaction_aborted - if a stm::transaction_aborted
+ is thrown the next commit will fail 5. do a no_throw commit (2)
+ 
+
+ Next follows the definition of the STM_ATOMIC and STM_END_ATOMIC macros.
+ 
+
+ To access this in the current transaction we use <code class="computeroutput">t.wr_ptr(this)</code>
+ which return a smart pointer.
+ 
+
+ If there is a large use of t.wr_ptr(this) it is better to use a variable
+ 
+<pre class="programlisting">{
+ STM_ATOMIC(t) {
+ stm::tx_wr_ptr<BankAccount> this_ptr(this,t);
+ this_ptr->balance_ += amount;
+ } STM_END_ATOMIC
+}
+</pre>
+
+ The other <code class="computeroutput">BankAccount</code> functions
+ are coded as expected. Here is the comple code:
+ 
+<pre class="programlisting">class BankAccount {
+ int balance_;
+ using stm:;
+public:
+ void Deposit(unsigned amount) {
+ STM_ATOMIC(t) {
+ t.wr_ptr(this)->balance_ += amount;
+ } STM_END_ATOMIC
+ }
+ void Withdraw(unsigned amount) {
+ STM_ATOMIC(t) {
+ t.wr_ptr(this)->balance_ -= amount;
+ }
+ }
+ int GetBalance() const {
+ STM_ATOMIC(t) {
+ return make_tx_rd_ptr(this,t)->balance_;
+ } STM_END_ATOMIC
+ }
+};
+</pre>
+
+ The transfer from accounts is done like:
+ 
+<pre class="programlisting">void Transfer(BankAccount* inA, BankAccount* outA, int amount) {
+ using stm;
+ STM_ATOMIC(t) {
+ t.wr_ptr(inA)->Withdraw(amount);
+ t.wr_ptr(outA)->Deposit(amount);
+ } STM_END_ATOMIC
+}
+</pre>
+
+ The core of all this stuff is <code class="computeroutput">stm::transaction</code>,
+ <code class="computeroutput">stm::tx_wr_ptr<></code>
+ and <code class="computeroutput">stm::tx_rd_ptr<></code>.
+ 
+
+ The interface of the transaction class is quite simple:
+ 
+<pre class="programlisting">class transaction {
+public:
+ bool commit();
+ bool no_throw_commit() throw();
+ void abort();
+
+ template <typename T>
+ shared_ptr<transactional_object_cache<T> > rd_ptr(T* ptr);
+
+ template <typename T>
+ shared_ptr<transactional_object_cache<T> > wr_ptr(T* ptr);
+
+ template <typename T> void delete_memory(T* ptr);
+ template <typename T>
+ shared_ptr<transactional_object_cache<T> > insert_in_new_cache(T* ptr);
+
+ transaction_state const & state() const;
+};
+</pre>
+
+ The smart pointer interfaces follows:
+ 
+<pre class="programlisting">template <typename T>
+class tx_rd_ptr {
+public:
+
+ typedef T element_type;
+ typedef T value_type;
+ typedef T * pointer;
+ typedef T& reference;
+
+ tx_rd_ptr(T* p, transaction& scope);
+
+ const T* operator->() const;
+ const T& operator*() const;
+ const T * get() const;
+};
+
+
+template <typename T>
+class tx_wr_ptr {
+public:
+
+ typedef T element_type;
+ typedef T value_type;
+ typedef T * pointer;
+ typedef T& reference;
+
+ tx_wr_ptr(T* p, transaction& scope);
+
+ T* operator->() const;
+ T& operator*() const;
+ T * get() const;
+
+ void delete_ptr();
+};
+</pre>
+
+ Let me start with the simple constructor:
+ 
+<pre class="programlisting">tx_wr_ptr(T* p);
+</pre>
+
+ This creates a smart pointer pointing to a specific transaction memory of
+ the current transaction.
+ 
+
+ It contains the classic functions of a smart pointer overloaded with <code class="computeroutput">const</code> or non <code class="computeroutput">const</code>.
+ 
+<pre class="programlisting">T* operator->() const;
+T& operator*() const;
+T * get() const;
+</pre>
+
+ <code class="computeroutput">tx_wr_ptr</code> points to a writable
+ cache. When we use one of the smart pointer operators, the pointers points
+ to a upgraded write cache specific to the transaction. In the example
+ 
+<pre class="programlisting">this_ptr->balance_ += amount;
+</pre>
+
+ the use of <code class="computeroutput">this_ptr->balance_</code> on the left hand side of the assignement
+ operator requires a non const access, so the upgrade to writable is done.
+ 
+
+ Every <code class="computeroutput">new</code>/<code class="computeroutput">delete</code>
+ operation on a transaction must be in some way signaled to the transaction
+ service. The new created objects would be wrapped by a <code class="computeroutput">tx_wr_ptr<></code> initialized like that;
+ 
+<pre class="programlisting">tx_wr_ptr<BankAccount> this_ptr(new BackAccount(), is_new);
+</pre>
+
+ When we want to delete a pointer in a transaction we use <code class="computeroutput">tx_wr_ptr::delete_ptr</code>
+ 
+<pre class="programlisting">tx_wr_ptr<BankAccount> p_ptr(p, t);
+// ...
+p_ptr.delete_ptr();
+</pre>
+
+ or the short-cut
+ 
+<pre class="programlisting">t.delete_ptr(p);
+</pre>
+
+ Before finishing with the <code class="computeroutput">transaction</code>
+ class let me show you the <code class="computeroutput">transactional_object_cache<T></code>
+ and its base class <code class="computeroutput">transactional_object_cache_base</code>.
+ 
+<pre class="programlisting">class transaction {
+public:
+ bool commit();
+ bool no_throw_commit();
+ void abort();
+
+ template <typename T>
+ shared_ptr<transactional_object_cache<T> > read(T* ptr);
+
+ template <typename T>
+ shared_ptr<transactional_object_cache<T> > write(T* ptr);
+
+ template <typename T> void delete_memory(T* ptr);
+ template <typename T>
+ shared_ptr<transactional_object_cache<T> > insert_in_new_cache(T* ptr);
+
+ transaction_state const & state() const;
+};
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="thread_safe_deferred_traces.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../appendices.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/examples/thread_safe_deferred_traces.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/examples/thread_safe_deferred_traces.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,337 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Thread
+ safe deferred traces</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../examples.html" title="Examples">
+<link rel="prev" href="../examples.html" title="Examples">
+<link rel="next" href="stm.html" title=" STM">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../examples.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="stm.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.examples.thread_safe_deferred_traces"></a><a href="thread_safe_deferred_traces.html" title="Thread
+ safe deferred traces">Thread
+ safe deferred traces</a>
+</h3></div></div></div>
+
+ When executing on a multi thread environment, the output lines on std::cout
+ could interleave. We can synchronize these outputs with a global mutex
+ 
+<pre class="programlisting">{
+ boost::lock_guard<boost::mutex> lock(global_cout_mutex);
+ std::cout << ... << std::endl ;
+}
+</pre>
+
+ This mutex could be the bottleneck of the system. Only one mutex resource
+ for all the user threads.
+ 
+<pre class="programlisting">U U
+ /
+ /
+ U ----- R ----- U
+ |
+ |
+ U
+</pre>
+
+ Another approach could be using a queue of output stream buffers for each
+ thread. Each buffer is timestamped with the creation date and there is a
+ concentrator that takes one by one the elements ordered by their timestamp.
+ Only the current thread can push on this queue because it is specific to
+ the thread. There is a single thread, the concentrator, that pops from these
+ queue. In this context we can ensure thread safety without locking as far
+ as the queue has at least two messages.
+ 
+<pre class="programlisting">U ----- R ------+
+ \
+ U ----- R ------\
+ \
+ U ----- R -------- C
+ / /
+ U ----- R ------/ /
+ /
+ U ----- R ------+
+</pre>
+
+ This can be encapsulated in an async_ostream class
+ 
+<pre class="programlisting">class async_ostream : public iostreams::stream<detail::async_ostream_sink> {
+public:
+ typedef char char_type;
+ typedef iostreams::sink_tag category;
+
+ async_ostream(std::ostream& os);
+ void flush();
+};
+
+extern async_ostream cout_;
+</pre>
+
+ With this interface the user can use cout_ as it used std::cout.
+ 
+<pre class="programlisting">cout_ << "Hello World!" << std::endl ;
+</pre>
+
+ All the magic is in the <code class="computeroutput">template class boost::iostreams::stream<></code>. The parameter must be a model of
+ a sink (See Boost.Iostreams). Here it is.
+ 
+<pre class="programlisting">namespace detail {
+ struct async_ostream_sink {
+ typedef char char_type;
+ typedef boost::iostreams::sink_tag category;
+ async_ostream_sink(std::ostream& os);
+ std::streamsize write(const char* s, std::streamsize n);
+ void flush();
+ private:
+ friend class async_ostream_concentrator;
+ friend class async_ostream;
+ struct impl;
+ boost::shared_ptr<impl> impl_;
+ };
+}
+</pre>
+
+ This class declares the just minimum in order to model a sink. In addition,
+ in order to mask the implementation, the Pimpl idiom is used. The implementation
+ of these functions is straigtforward:
+ 
+<pre class="programlisting">async_ostream::async_ostream(std::ostream& os)
+ : base_type(os) {}
+
+void async_ostream::flush() {
+ this->base_type::flush();
+ async_ostream& d = *this;
+ d->flush();
+}
+
+async_ostream_sink::async_ostream_sink(std::ostream& os)
+ : impl_(new async_ostream_sink::impl(os)) {}
+
+std::streamsize detail::async_ostream_sink::write(const char* s, std::streamsize n) {
+ return impl_->write(s,n);
+}
+
+void async_ostream_sink::flush() {
+ return impl_->flush();
+}
+</pre>
+
+ Let me continue with the handle of the Pimpl pattern:
+ 
+<pre class="programlisting">struct detail::async_ostream_sink::impl {
+ impl(std::ostream& os);
+ std::ostream& os_;
+ tsss_type tsss_;
+ priority_queue_type queue_;
+ boost::thread thread_;
+
+ std::streamsize write(const char* s, std::streamsize n);
+
+ static void terminate(shared_ptr<async_ostream_thread_ctx> that);
+ static void loop(impl* that);
+};
+</pre>
+
+ Of course we need to store a reference to the final ostream.
+ 
+
+ The <code class="computeroutput">thread_specific_shared_ptr
+ tsss_</code> is used to encapsulate the
+ logic specific to each thread.
+ 
+<pre class="programlisting">typedef thread_specific_shared_ptr<async_ostream_thread_ctx> tsss_type;
+</pre>
+
+ A priority queue <code class="computeroutput">queue_</code> will
+ be used by the concentrator thread to order the stringstreams by date.
+ 
+<pre class="programlisting">template <typename T>
+struct detail::timestamped {
+ system_time date_;
+ unsigned seq_;
+ T value_;
+ void reset_date(unsigned seq) {
+ date_ = system_time();
+ seq_ = seq;
+ }
+ struct ptr_comparator_gt {
+ typedef timestamped* value_type;
+ bool operator()(const value_type&lhs, const value_type&rhs) {
+ return (lhs->date_ > rhs->date_) ? true :
+ (lhs->date_ == rhs->date_) && (lhs->seq_ > rhs->seq_)? true:false;
+ }
+ };
+};
+
+typedef timestamped<std::stringstream> element_type;
+typedef std::priority_queue<queue_type*, std::deque<element_type*>, element_type::ptr_comparator_gt> priority_queue_type;
+</pre>
+
+ In addition to the timestamp <code class="computeroutput">date_</code>
+ we need a sequence number to order the stringstreams pushed without enough
+ time granularity, e.g. on the same microsecond.
+ 
+
+ To finish the field declaration there is the concentrator thread implemented
+ by the loop function.
+ 
+<pre class="programlisting">, thread_(boost::bind(loop, this))
+</pre>
+
+ Comming back to the sink implementation,
+ 
+<pre class="programlisting">async_ostream_sink::impl::impl(std::ostream& os)
+: os_(os)
+, tsss_(terminate)
+, thread_(boost::bind(loop, this))
+{}
+</pre>
+
+ The terminate cleanup function is used to ensure that the queue is empty
+ before the thread finishes. To avoid optimizations a non const call inc is
+ done while waiting the queue empties.
+ 
+<pre class="programlisting">void async_ostream_sink::impl::terminate(shared_ptr<async_ostream_thread_ctx> that) {
+ while (!that->empty()) {
+ that->inc();
+ }
+}
+</pre>
+
+ The central sink function is write. Here instead to lock a mutex the function
+ forwards to the thread specific shared pointer. We will see below how <code class="computeroutput">async_ostream_thread_ctx</code> handles this call.
+ 
+<pre class="programlisting">std::streamsize write(const char* s, std::streamsize n) {
+ return tsss_->write(s, n);
+}
+</pre>
+
+ It is time to analyze the thread specific context before seeing how the concentrator
+ is implemented.
+ 
+<pre class="programlisting">struct async_ostream_thread_ctx {
+ async_ostream_thread_ctx();
+ std::streamsize write(const char* s, std::streamsize n);
+ void flush();
+ element_type* get();
+ bool empty() const {return queue_.empty();}
+ void inc() {++inc_;}
+private:
+ unsigned seq_;
+ element_type *current_;
+ queue_type queue_;
+ boost::mutex mutex_;
+ std::stringstream& buffer() {return current_->value_;}
+};
+</pre>
+
+ Each thread has a pointer to the current timestamped stringstream wich is
+ used for the current output flow, i.e. by the write function.
+ 
+<pre class="programlisting">std::streamsize write(const char* s, std::streamsize n) {
+ buffer().write(s, n);
+ return n;
+}
+</pre>
+
+ Once the user does a flush, the current element is pushed on the queue. The
+ <code class="computeroutput">sec_</code> integer is used as monotonic
+ sequence in conjuntion with the timestamp.
+ 
+<pre class="programlisting">void flush() {
+ current_->reset_date(seq_);
+ ++seq_;
+ if (queue_.size()>2) {
+ queue_.push(current_);
+ } else {
+ boost::lock_guard<boost::mutex> lock(mutex_);
+ queue_.push(current_);
+ }
+ current_ = new element_type();
+}
+</pre>
+
+ As stated in the introduction, we don't need to lock the mutex if the number
+ of elements in the queue is enough.
+ 
+
+ These queue elements will be read by the concentrator using the get function.
+ 
+<pre class="programlisting">element_type* get() {
+ if (queue_.size()>1) {
+ return get_i();
+ } else {
+ boost::lock_guard<boost::mutex> lock(mutex_);
+ return get_i();
+ }
+}
+
+element_type* get_i() {
+ if (queue_.empty()) return 0;
+ element_type* e= queue_.front();
+ queue_.pop();
+ return e;
+}
+</pre>
+
+ The concentrator loop looks like:
+ 
+<pre class="programlisting">void async_ostream_sink_impl::loop(async_ostream_sink::impl* that) {
+ std::ostream& os_ = that->os_;
+ for(;;) {
+ // sleeps a little bit
+ this_thread::sleep(boost::posix_time::milliseconds(1));
+ { // scope needed don't remove
+ // lock the map access
+ tsss_type::lock_type lock(that->tsss_.get_mutex());
+ const tsss_type::map_type& tmap(that->tsss_.get_map(lock));
+ for (tsss_type::map_type::const_iterator it = tmap.begin(); it != tmap.end(); ++it) {
+ // takes the first element of each thread queue (if it exists) and push it on the ordered queue.
+ element_type* e= it->second->get();
+ if (e != 0) that->queue_.push(e);
+ }
+ }
+ if (that->queue_.empty()) { //when the queue is empty sleeps a little more
+ this_thread::sleep(boost::posix_time::milliseconds(10));
+ } else {
+ // takes the fist element of the ordered queue, write them on the output stream and delete it.
+ element_type* e = that->queue_.top();
+ that->queue_.pop();
+ os_ << "["<< e->date_ <<"-" << e->seq_ << "] " << e->value_.str();
+ delete e;
+ }
+ }
+}
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../examples.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../examples.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="stm.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/overview.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/overview.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,180 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Overview</title>
+<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../index.html" title="Toward Boost.InterThreads">
+<link rel="prev" href="../index.html" title="Toward Boost.InterThreads">
+<link rel="next" href="overview/motivation.html" title=" Motivation">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="overview/motivation.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="toward_boost_interthreads.overview"></a> Overview
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt> Motivation</dt>
+<dd><dl>
+<dt>Decorators</dt>
+<dt><a href="overview/motivation.html#toward_boost_interthreads.overview.motivation.sharing_thread_local_storage">Sharing
+ Thread Local Storage</a></dt>
+<dt><a href="overview/motivation.html#toward_boost_interthreads.overview.motivation.keep_alive_motivation">
+ Keep Alive</a></dt>
+<dt><a href="overview/motivation.html#toward_boost_interthreads.overview.motivation.thread_tuple">Thread
+ Tuple</a></dt>
+</dl></dd>
+</dl></div>
+<a name="toward_boost_interthreads.overview.description"></a><h3>
+<a name="id4803164"></a>
+ Description
+ </h3>
+
+ Boost.InterThreads extends Boost.Threads adding some features:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ A thread_decoration class allowing to define setup/cleanup functions which
+ will be called only once by thread (if the thread function is decorated with
+ thread_decorator): setup before the thread function and cleanup at thread
+ exit. It is used together with asynchronous_executor_decorator
+ </li>
+<li>
+ A thread_decorator/thread_decorate class/function which decorate a thread
+ function in order to call the setup and the cleanup of all the thread_decorations.
+ </li>
+<li>
+ A thread specific shared pointer which is an extension of the thread_specific_ptr
+ providing access to this thread specific context from other threads. As it
+ is shared the stored pointer is a shared_ptr instead of a raw one.
+ </li>
+<li>
+ A thread keep alive mechanism: this mechanism allows to detect threads that
+ do not prove that they are alive by calling to the keep_alive_point regularly.
+ When a thread is declared dead a user provided function is called, which
+ by default will abort the program.
+ </li>
+<li>
+ A thread static array
+ <div class="itemizedlist"><ul type="circle"><li>
+ thread tuple: defines a thread groupe where the number of threads is
+ know statically and the threads are created at construction time in oposition
+ to a thread_group.
+ </li></ul></div>
+</li>
+<li>
+ A thread static array and a thread group with wait for any feature
+ <div class="itemizedlist"><ul type="circle">
+<li>
+ set_once: a synchonizer that allows to set a variable only once, notifying
+ to the variable value to whatever is waiting for that.
+ </li>
+<li>
+ thread_tuple_once: an extension of the boost::thread_tuple which allows
+ to join the completion of any thread using for that the set_once synchronizer.
+ </li>
+<li>
+ thread_group_once: an extension of the boost::thread_group which allows
+ to join the completion of any thread in the group using for that the
+ set_once synchronizer.
+ </li>
+</ul></div>
+</li>
+</ul></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ thread_decorator and thread_specific_shared_ptr are based on the original
+ implementation of threadalert written by Roland Schwarz.
+ </td></tr>
+</table></div>
+<a name="toward_boost_interthreads.overview.how_to_use_this_documentation"></a><h3>
+<a name="id4764766"></a>
+ <a href="overview.html#toward_boost_interthreads.overview.how_to_use_this_documentation">How
+ to Use This Documentation</a>
+ </h3>
+
+ This documentation makes use of the following naming and formatting conventions.
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ Code is in <code class="computeroutput">fixed width
+ font</code> and is syntax-highlighted.
+ </li>
+<li>
+ Replaceable text that you will need to supply is in
+ <code>
+ italics
+ </code>
+ .
+ </li>
+<li>
+ If a name refers to a free function, it is specified like this: <code class="computeroutput">free_function()</code>;
+ that is, it is in code font and its name is followed by <code class="computeroutput">()</code>
+ to indicate that it is a free function.
+ </li>
+<li>
+ If a name refers to a class template, it is specified like this: <code class="computeroutput">class_template<></code>;
+ that is, it is in code font and its name is followed by <code class="computeroutput"><></code>
+ to indicate that it is a class template.
+ </li>
+<li>
+ If a name refers to a function-like macro, it is specified like this: <code class="computeroutput">MACRO()</code>;
+ that is, it is uppercase in code font and its name is followed by <code class="computeroutput">()</code> to indicate that it is a function-like
+ macro. Object-like macros appear without the trailing <code class="computeroutput">()</code>.
+ </li>
+<li>
+ Names that refer to concepts in the generic programming
+ sense are specified in CamelCase.
+ </li>
+</ul></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ In addition, notes such as this one specify non-essential information that
+ provides additional background or rationale.
+ </td></tr>
+</table></div>
+
+ Finally, you can mentally add the following to any code fragments in this document:
+ 
+<pre class="programlisting">// Include all of InterThreads
+#include <boost/interthreads/interthreads.hpp>
+
+// Create a namespace aliases
+namespace bith = boost::interthreads;
+</pre>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../index.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="overview/motivation.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/overview/motivation.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/overview/motivation.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,271 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Motivation</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../overview.html" title=" Overview">
+<link rel="prev" href="../overview.html" title=" Overview">
+<link rel="next" href="../users_guide.html" title=" Users'Guide">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../overview.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../overview.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../users_guide.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.overview.motivation"></a> Motivation
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt>Decorators</dt>
+<dt><a href="motivation.html#toward_boost_interthreads.overview.motivation.sharing_thread_local_storage">Sharing
+ Thread Local Storage</a></dt>
+<dt><a href="motivation.html#toward_boost_interthreads.overview.motivation.keep_alive_motivation">
+ Keep Alive</a></dt>
+<dt><a href="motivation.html#toward_boost_interthreads.overview.motivation.thread_tuple">Thread
+ Tuple</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.overview.motivation.decorators"></a>Decorators
+</h4></div></div></div>
+
+ <code class="computeroutput">boost::call_once</code> provides a mechanism for ensuring
+ that an initialization routine is run exactly once on a programm without
+ data races or deadlocks. <code class="computeroutput">boost::this_thread::at_thread_exit</code>
+ allows to execute a cleanup function at thread exit.
+ 
+
+ If we want a setup function to be executed once at the begining on the
+ threads and a cleanup at thread exit we need to do
+ 
+<pre class="programlisting">void thread_main() {
+ setup();
+ boost::this_thread::at_thread_exit(cleanup);
+ // do whatever
+ // ...
+}
+// ...
+{
+ launch(thread_main);
+ //...
+}
+</pre>
+
+ Of course we can define an init function that calls setup and do the registration.
+ 
+<pre class="programlisting">void init() {
+ setup();
+ boost::this_thread::at_thread_exit(cleanup);
+}
+</pre>
+
+ Different services could require these setup/cleanup functions to be called,
+ and so each thread function should do
+ 
+<pre class="programlisting">void thread_main() {
+ serv1::init();
+ // ...
+ servN::init();
+ // do whatever using serv1, ..., servN.
+ // ...
+}
+</pre>
+
+ This approach is valid for services that the user can configure for specifics
+ threads, but not for services that must be installed on every thread.
+ 
+
+ <code class="computeroutput">thread_decoration</code> ensures
+ that a setup function is called only once by thread before the thread function
+ provided the thread is created with a decorator wrapper. This setup function
+ is usualy used to set thread specific pointers and call functions once.
+ 
+
+ The conterpart of the setup is the cleanup. The <code class="computeroutput">thread_decoration</code>
+ takes an optional cleanup function which will be executed at thread exit.
+ 
+<pre class="programlisting">// define in only the implementation file of each service
+
+boost::interthreads::decoration serv1:decoration(serv1:setup, serv1:cleanup);
+// ...
+boost::interthreads::decoration servN:decoration(servN:setup, servN:cleanup);
+
+
+void thread_main() {
+ // do whatever using serv1, ..., servN.
+ // ...
+}
+
+// ...
+{
+ boost::thread th(boost::interthreads::make_decorator(thread_main));
+ //...
+}
+</pre>
+
+ We can use a basic_threader_decorator as asynchronous executor to fork
+ thread_main.
+ 
+<pre class="programlisting">// ...
+{
+ boost::thread th=fork(basic_threader_decorator(), thread_main);
+ //...
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.overview.motivation.sharing_thread_local_storage"></a><a href="motivation.html#toward_boost_interthreads.overview.motivation.sharing_thread_local_storage" title="Sharing
+ Thread Local Storage">Sharing
+ Thread Local Storage</a>
+</h4></div></div></div>
+
+ Thread local storage allows multi-threaded applications to have a separate
+ instance of a given data item for each thread. But does not provide any
+ mechanism to access this data from other threads. Although this seems to
+ defeat the whole point of thread-specific storage, it is useful when these
+ contexts need some kind of communication between them, or some central
+ global object needs to control them.
+ 
+
+ The intent of the <code class="computeroutput">boost::thread_specific_shared_ptr</code>
+ class is to allow two threads to establish a shared memory space, without
+ requiring the user code to pass any information. <code class="computeroutput">boost::thread_specific_shared_ptr</code>
+ provides a portable mechanism for shared thread-local storage that works
+ on all compilers supported by <code class="computeroutput">boost::thread</code>
+ and <code class="computeroutput">boost::shared_ptr</code>. Each instance of <code class="computeroutput">boost::thread_specific_shared_ptr</code> represents
+ a pointer to a shared object where each thread must have a distinct value.
+ 
+
+ Only the current thread can modify the thread specific shared pointer using
+ the non const functions reset/release functions. Each time these functions
+ are used, a synchronization must be ensured to update the mapping. The
+ other threads have only read access to the shared_ptr<T>. It is worth
+ saying that the shared object T must be thread safe.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.overview.motivation.keep_alive_motivation"></a><a href="motivation.html#toward_boost_interthreads.overview.motivation.keep_alive_motivation" title="
+ Keep Alive">
+ Keep Alive</a>
+</h4></div></div></div>
+
+ On fault tolerant systems we need to be able to detect threads that could
+ stay on a loop, or simply blocked.
+ 
+
+ One way to detect this situations is to require the thread to signal it
+ is alive by calling a check point function. Of course it should be up to
+ the user to state when this mechanism is enabled or disabled. At the begining
+ of a thread the keep alive mechanism is disabled.
+ 
+
+ A thread will be considered dead if during a given period the number of
+ checkins is inferior to a given threshold. These two parameters can be
+ given when the keep alive mechanislm is enabled.
+ 
+
+ The controler checks at predefined intervals if the thread is dead, and
+ in this case it will call a user specific function which by default aborts
+ the program.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.overview.motivation.thread_tuple"></a><a href="motivation.html#toward_boost_interthreads.overview.motivation.thread_tuple" title="Thread
+ Tuple">Thread
+ Tuple</a>
+</h4></div></div></div>
+
+ The <code class="computeroutput">boots::thread_group</code> class allows to group dynamically
+ threads. This means that the container must be dynamic.
+ 
+<pre class="programlisting">{
+ boost::thread_group tg;
+ tg.create_thread(thread1);
+ tg.create_thread(thread2);
+ tg.join_all(thread1);
+}
+</pre>
+
+ The <code class="computeroutput">thread_tuple<></code>
+ class is responsible for launching and managing a static collection of
+ threads that are related in some way. No new threads can be added to the
+ tuple once constructed. So we can write
+ 
+<pre class="programlisting">{
+ bith::thread_tuple<2> tt(thread1, thread2);
+ tt.join_all(thread1);
+}
+</pre>
+
+ As this
+ 
+<pre class="programlisting">bith::conc_join_all(thread1, thread2);
+</pre>
+
+ In addition the user can join the first finishing thread.
+ 
+<pre class="programlisting">unsigned i = bith::conc_join_any(thread1, thread2);
+</pre>
+
+ Evidently, thread_tuple can not be used when we need dynamic creation or
+ deletion. The <code class="computeroutput">boots::thread_group</code> class allows to group dynamically
+ threads.
+ 
+<pre class="programlisting">{
+ boost::thread_group tg;
+ tg.create_thread(thread1);
+
+ // later on
+ tg.create_thread(thread2);
+ boost::thread th3(thread3)
+ tg.add_thread(th3);
+
+ // later on
+ tg.remove_thread(th3);
+
+ tg.join_all(thread1);
+}
+</pre>
+
+ Objects of type <code class="computeroutput">thread_tuple<></code> are movable, so they can be stored
+ in move-aware containers, and returned from functions. This allows the
+ details of thread tuple creation to be wrapped in a function.
+ 
+<pre class="programlisting">boost::interthreads::thread_tuple<2> make_thread_tuple(...);
+
+void f()
+{
+ bith::thread_tuple<2> some_thread_tuple=bith::make_thread_tuple(f1, g2);
+ some_thread_tuple.join();
+}
+</pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../overview.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../overview.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../users_guide.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,71 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Reference</title>
+<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../index.html" title="Toward Boost.InterThreads">
+<link rel="prev" href="users_guide/glosary.html" title=" Glossary">
+<link rel="next" href="reference/concepts.html" title="Concepts">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="users_guide/glosary.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference/concepts.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="toward_boost_interthreads.reference"></a> Reference
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt>Concepts</dt>
+<dd><dl><dt>Decorator</dt></dl></dd>
+<dt><a href="reference/thread_extensions_reference.html">Thread
+ Extensions Reference</a></dt>
+<dd><dl>
+<dt><a href="reference/thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_decoration.hpp></code></a></dt>
+<dt><a href="reference/thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_decorator.hpp></code></a></dt>
+<dt><a href="reference/thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_specific_shared_ptr.hpp></code></a></dt>
+<dt><a href="reference/thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_keep_alive.hpp></code></a></dt>
+</dl></dd>
+<dt><a href="reference/thread_array_reference.html">Thread
+ Array Reference</a></dt>
+<dd><dl>
+<dt><a href="reference/thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.set_once_hpp">
+ Header <code class="computeroutput"><boost/interthreads/set_once.hpp></code></a></dt>
+<dt><a href="reference/thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_tuple.hpp></code></a></dt>
+<dt><a href="reference/thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_tuple_once.hpp></code></a></dt>
+<dt><a href="reference/thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_group_once.hpp></code></a></dt>
+</dl></dd>
+</dl></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="users_guide/glosary.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="reference/concepts.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference/concepts.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference/concepts.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,48 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Concepts</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../reference.html" title=" Reference">
+<link rel="prev" href="../reference.html" title=" Reference">
+<link rel="next" href="thread_extensions_reference.html" title="Thread
+ Extensions Reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../reference.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="thread_extensions_reference.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.reference.concepts"></a>Concepts
+</h3></div></div></div>
+<div class="toc"><dl><dt>Decorator</dt></dl></div>
+<div class="section" lang="en"><div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.reference.concepts.decorator"></a>Decorator
+</h4></div></div></div></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../reference.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="thread_extensions_reference.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference/thread_array_reference.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference/thread_array_reference.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,1429 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Thread
+ Array Reference</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../reference.html" title=" Reference">
+<link rel="prev" href="thread_extensions_reference.html" title="Thread
+ Extensions Reference">
+<link rel="next" href="../examples.html" title="Examples">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="thread_extensions_reference.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../examples.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference"></a><a href="thread_array_reference.html" title="Thread
+ Array Reference">Thread
+ Array Reference</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.set_once_hpp">
+ Header <code class="computeroutput"><boost/interthreads/set_once.hpp></code></a></dt>
+<dd><dl><dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.set_once_hpp.set_onceclass">
+ Template Class <code class="computeroutput">set_once<></code></a></dt></dl></dd>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_tuple.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class">
+ Template Class <code class="computeroutput">thread_tuple<></code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_make_thread_tuple">
+ Non Member Function <code class="computeroutput">make_thread_tuple()</code></a></dt>
+</dl></dd>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_tuple_once.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class">
+ Template Class <code class="computeroutput">thread_tuple_once<></code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_make_thread_tuple_once">
+ Non Member Function <code class="computeroutput">make_thread_tuple_once()</code></a></dt>
+</dl></dd>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_group_once.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class">
+ Template Class <code class="computeroutput">thread_group_once<></code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_make_thread_group_once">
+ Non Member Function <code class="computeroutput">make_thread_group_once()</code></a></dt>
+</dl></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.set_once_hpp"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.set_once_hpp" title="
+ Header <boost/interthreads/set_once.hpp>">
+ Header <code class="computeroutput"><boost/interthreads/set_once.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.set_once_hpp.set_onceclass">
+ Template Class <code class="computeroutput">set_once<></code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+namespace interthreads {
+ template <typename T>
+ class set_once;
+}
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.set_once_hpp.set_onceclass"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.set_once_hpp.set_onceclass" title="
+ Template Class set_once<>">
+ Template Class <code class="computeroutput">set_once<></code></a>
+</h5></div></div></div>
+
+ <code class="computeroutput">set_once<></code>
+ is a synchonizer that allows to set a variable only once, notifying to
+ the variable value to whatever is waiting for that.
+ 
+<pre class="programlisting">template <typename T>
+class set_once {
+public:
+ typedef T value_type;
+
+ set_once();
+ void wait();
+ bool wait_until(const system_time& abs_time);
+ template<typename TimeDuration>
+ bool wait_for(const TimeDuration& rel_time);
+
+ value_type get();
+ std::pair<bool,value_type> get_until(const system_time& abs_time);
+ template<typename TimeDuration>
+ std::pair<bool,value_type> get_for(const TimeDuration& rel_time);
+
+ bool set_if_unassigned(value_type id);
+
+ template<typename F>
+ static void decorator(this_type& once, T value, F fct);
+ template<typename F>
+ static boost::detail::thread_move_t<thread> make_thread(this_type& once, T value, F fct);
+};
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp" title="
+ Header <boost/interthreads/thread_tuple.hpp>">
+ Header <code class="computeroutput"><boost/interthreads/thread_tuple.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class">
+ Template Class <code class="computeroutput">thread_tuple<></code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_make_thread_tuple">
+ Non Member Function <code class="computeroutput">make_thread_tuple()</code></a></dt>
+</dl></div>
+<pre class="programlisting">namespace boost {
+namespace interthreads {
+
+ template <std::size_t N>
+ class thread_tuple;
+
+ template<typename F0, ..., typename Fn-1>
+ thread_tuple<n> make_thread_tuple(F0 f0, ..., Fn fn-1);
+
+}
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class" title="
+ Template Class thread_tuple<>">
+ Template Class <code class="computeroutput">thread_tuple<></code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.template_parameters">Template
+ parameters</a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_callable_constructor">
+ Constructor</a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_destructor">
+ Destructor</a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_joinable">
+ Member function <code class="computeroutput">joinable()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_join">
+ Member function <code class="computeroutput">join_all()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.member_function__join_all_until___">Member
+ function <code class="computeroutput">join_all_until()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.member_function__join_all_for___">Member
+ function <code class="computeroutput">join_all_for()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.join_first_then_interrupt">
+ Member function <code class="computeroutput">join_any()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.member_function__join_any_until___">Member
+ function <code class="computeroutput">join_any_until()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.detach_all">
+ Member function <code class="computeroutput">detach_all()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_interrupt_all">
+ Member function <code class="computeroutput">interrupt_all()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_size">
+ Member function <code class="computeroutput">size()</code></a></dt>
+</dl></div>
+
+ <code class="computeroutput">thread_tuple<></code>
+ defines a thread groupe where the number of threads is know statically
+ and the threads are created at construction time.
+ 
+<pre class="programlisting">template <std::size_t n>
+class thread_tuple {
+public:
+ template<typename F0, ..., typename Fn-1>
+ thread_tuple(F0 f0, ..., Fn-1 fn-1);
+
+ template <class F>
+ thread_tuple(boost::move_t<F> f);
+ ~thread_tuple();
+
+ // move support
+ thread_tuple(boost::move_t<thread_tuple<n>> x);
+ thread_tuple& operator=(boost::move_t<thread_tuple<n>> x);
+ operator boost::move_t<thread_tuple<n>>();
+ boost::move_t<thread_tuple<n>> move();
+
+ void swap(thread_tuple<n>& x);
+
+ bool joinable() const;
+ void join_all();
+ bool join_all_until(const system_time& wait_until);
+ template<typename TimeDuration>
+ bool join_all_for(TimeDuration const& rel_time);
+
+ void detach();
+ void detach_all();
+
+ void interrupt();
+ void interrupt_all();
+ bool interruption_requested() const;
+
+ size_t size();
+
+ const thread& operator[](std::size_t i);
+};
+}
+}
+</pre>
+
+ The <code class="computeroutput">thread_tuple<></code>
+ class is responsible for launching and managing a static collection of
+ threads that are related in some fashion. No new threads can be added
+ to the tuple once constructed.
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.template_parameters"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.template_parameters" title="Template
+ parameters">Template
+ parameters</a>
+</h6></div></div></div>
+
+ <code class="computeroutput">thread_tuple<></code>
+ is instantiated with the following value:
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ n is the size of the tuple.
+ </li></ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_callable_constructor"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_callable_constructor" title="
+ Constructor">
+ Constructor</a>
+</h6></div></div></div>
+<pre class="programlisting">template<typename F0, ..., typename Fn-1>
+thread_tuple(F0 func_0, ..., Fn-1 func_n-1);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Preconditions:</dt>
+<dd>
+ <code class="computeroutput">Fk</code> must by copyable.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ <code class="computeroutput">func_k</code> is copied
+ into storage managed internally by the library, and that copy is
+ invoked on a newly-created thread of execution. If this invocation
+ results in an exception being propagated into the internals of
+ the library that is not of type <code class="computeroutput">boost::thread_interrupted</code>,
+ then <code class="computeroutput">std::terminate()</code>
+ will be called.
+ </dd>
+<dt>Postconditions:</dt>
+<dd>
+ <code class="computeroutput">*this</code>
+ refers to the newly created tuple of threads of execution.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::thread_resource_error</code> if an error
+ occurs.
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Currently up to ten arguments <code class="computeroutput">func_0</code>
+ to <code class="computeroutput">funct_9</code> can
+ be specified.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_destructor"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_destructor" title="
+ Destructor">
+ Destructor</a>
+</h6></div></div></div>
+<pre class="programlisting">~thread_tuple();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ If *this have associateds thread of execution, calls detach() on
+ them. Destroys *this.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_joinable"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_joinable" title="
+ Member function joinable()">
+ Member function <code class="computeroutput">joinable()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">bool joinable() const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Returns:</dt>
+<dd>
+ <code class="computeroutput">true</code> if <code class="computeroutput">*this</code>
+ refers to threads of execution, <code class="computeroutput">false</code>
+ otherwise.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_join"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_join" title="
+ Member function join_all()">
+ Member function <code class="computeroutput">join_all()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void join();
+void join_all();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">join()</code>
+ on each <code class="computeroutput">boost::thread</code> object in the tuple.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the tuple has terminated.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">boost::thread::join</code> is one of the predefined
+ interruption points, <code class="computeroutput">thread_tuple<>::join_all()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.member_function__join_all_until___"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.member_function__join_all_until___" title="Member
+ function join_all_until()">Member
+ function <code class="computeroutput">join_all_until()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">bool join_all_until(const system_time& wait_until);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">timed_join()</code> on each <code class="computeroutput">boost::thread</code>
+ object in the tuple.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the tuple has terminated.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ true if joined.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">boost::thread::timed_join</code> is one of the predefined
+ interruption points, <code class="computeroutput">thread_tuple<>::join_all_until()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.member_function__join_all_for___"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.member_function__join_all_for___" title="Member
+ function join_all_for()">Member
+ function <code class="computeroutput">join_all_for()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">template<typename TimeDuration>
+bool join_for(TimeDuration const& rel_time);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ As <code class="computeroutput">join_all_until(now()+rel_time)</code>.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the tuple has terminated.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ true if joined.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">boost::thread::timed_join</code> is one of the predefined
+ interruption points, <code class="computeroutput">thread_tuple<>::join_all_for()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.join_first_then_interrupt"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.join_first_then_interrupt" title="
+ Member function join_any()">
+ Member function <code class="computeroutput">join_any()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">std::size_t conc_join_any();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">join_any()</code>
+ on a temporary thread_tuple and the <code class="computeroutput">interrup_all()</code>.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the tuple has terminated.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">join_any()</code> is one of the predefined interruption
+ points, <code class="computeroutput">conc_join_any()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.member_function__join_any_until___"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.member_function__join_any_until___" title="Member
+ function join_any_until()">Member
+ function <code class="computeroutput">join_any_until()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">std::pair<bool,std::size_t> conc_join_any_until(
+ const system_time& wait_until);
+template<typename TimeDuration>
+std::pair<bool,std::size_t> join_any_for(
+ TimeDuration const& rel_time);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">join_any_until()</code> on a temporary thread_tuple and
+ the <code class="computeroutput">interrup_all()</code>.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the tuple has terminated.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ true if joined.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">join_any_until()</code> is one of the predefined interruption
+ points, <code class="computeroutput">conc_join_any_until()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.detach_all"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.detach_all" title="
+ Member function detach_all()">
+ Member function <code class="computeroutput">detach_all()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void detach_all();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">detach()</code>
+ on each <code class="computeroutput">boost::thread</code> object in the tuple.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_interrupt_all"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_interrupt_all" title="
+ Member function interrupt_all()">
+ Member function <code class="computeroutput">interrupt_all()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void interrupt_all();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">thread::interrupt()</code>
+ on each <code class="computeroutput">boost::thread</code> object in the tuple.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_size"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_class.thread_tuple_size" title="
+ Member function size()">
+ Member function <code class="computeroutput">size()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">int size();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Returns:</dt>
+<dd>
+ The number of threads in the tuple.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_make_thread_tuple"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_hpp.thread_tuple_make_thread_tuple" title="
+ Non Member Function make_thread_tuple()">
+ Non Member Function <code class="computeroutput">make_thread_tuple()</code></a>
+</h5></div></div></div>
+<pre class="programlisting">template<typename F0, ..., typename Fn-1>
+thread_tuple make_thread_tuple(F0 f0, ..., Fn fn-1);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ makes a new thread_tuple<>.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ the created thread tuple.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp" title="
+ Header <boost/interthreads/thread_tuple_once.hpp>">
+ Header <code class="computeroutput"><boost/interthreads/thread_tuple_once.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class">
+ Template Class <code class="computeroutput">thread_tuple_once<></code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_make_thread_tuple_once">
+ Non Member Function <code class="computeroutput">make_thread_tuple_once()</code></a></dt>
+</dl></div>
+<pre class="programlisting">namespace boost {
+namespace interthreads {
+
+ template <std::size_t N>
+ class thread_tuple_once;
+
+ template<typename F0, ..., typename Fn-1>
+ thread_tuple make_thread_tuple_once(F0 f0, ..., Fn fn-1);
+
+}
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class" title="
+ Template Class thread_tuple_once<>">
+ Template Class <code class="computeroutput">thread_tuple_once<></code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.template_parameters">Template
+ parameters</a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_callable_constructor">
+ Constructor</a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_destructor">
+ Destructor</a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_joinable">
+ Member function <code class="computeroutput">joinables()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_join">
+ Member function <code class="computeroutput">join_all()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.member_function__join_all_until___">Member
+ function <code class="computeroutput">join_all_until()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.member_function__join_any___">Member
+ function <code class="computeroutput">join_any()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.timed_join_first_then_interrupt">
+ Member function <code class="computeroutput">timed_join_first_then_interrupt()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.detach_all">
+ Member function <code class="computeroutput">detach_all()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_interrupt_all">
+ Member function <code class="computeroutput">interrupt_all()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_size">
+ Member function <code class="computeroutput">size()</code></a></dt>
+</dl></div>
+
+ <code class="computeroutput">biththread_tuple_once</code>
+ is an extension of the <code class="computeroutput">bith::thread_tuple</code>
+ which allows to join the thread finishing the first, using for that the
+ <code class="computeroutput">bith::set_once</code> synchronizer.
+ 
+<pre class="programlisting">template <std::size_t n>
+class thread_tuple_once {
+public:
+ template<typename F0, ..., typename Fn-1>
+ thread_tuple_once(F0 f0, ..., Fn-1 fn-1);
+
+ template <class F>
+ thread_tuple_once(boost::move_t<F> f);
+ ~thread_tuple_once();
+
+ // move support
+ thread_tuple_once(boost::move_t<thread_tuple_once<n>> x);
+ thread_tuple_once& operator=(boost::move_t<thread_tuple_once<n>> x);
+ operator boost::move_t<thread_tuple_once<n>>();
+ boost::move_t<thread_tuple_once<n>> move();
+
+ void swap(thread_tuple_once<n>& x);
+
+ bool joinables() const;
+ void join_all();
+ bool join_all_until(const system_time& wait_until);
+ template<typename TimeDuration>
+ bool join_all_for(TimeDuration const& rel_time);
+
+ std::size_t join_any();
+ std::pair<bool,std::size_t> join_any_until(
+ const system_time& wait_until);
+ template<typename TimeDuration>
+ std::pair<bool,std::size_t> join_any_for(
+ TimeDuration const& rel_time);
+
+ void detach_all();
+
+ void interrupt_all();
+ bool interruption_requested() const;
+
+ size_t size();
+
+ const thread& operator[](std::size_t i);
+};
+}
+}
+</pre>
+
+ The __thread_tupleonce_ class is
+ responsible for launching and managing a static collection of threads
+ that are related in some fashion. No new threads can be added to the
+ tuple once constructed.
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.template_parameters"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.template_parameters" title="Template
+ parameters">Template
+ parameters</a>
+</h6></div></div></div>
+
+ <code class="computeroutput">thread_tuple_once<></code>
+ is instantiated with the following value:
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ n is the size of the tuple.
+ </li></ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_callable_constructor"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_callable_constructor" title="
+ Constructor">
+ Constructor</a>
+</h6></div></div></div>
+<pre class="programlisting">template<typename F0, ..., typename Fn-1>
+thread_tuple_once(F0 func_0, ..., Fn-1 func_n-1);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Preconditions:</dt>
+<dd>
+ <code class="computeroutput">Fk</code> must by copyable.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ <code class="computeroutput">func_k</code> is copied
+ into storage managed internally by the library, and that copy is
+ invoked on a newly-created thread of execution. If this invocation
+ results in an exception being propagated into the internals of
+ the library that is not of type <code class="computeroutput">boost::thread_interrupted</code>,
+ then <code class="computeroutput">std::terminate()</code>
+ will be called.
+ </dd>
+<dt>Postconditions:</dt>
+<dd>
+ <code class="computeroutput">*this</code>
+ refers to the newly created tuple of threads of execution.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::thread_resource_error</code> if an error
+ occurs.
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Currently up to ten arguments <code class="computeroutput">func_0</code>
+ to <code class="computeroutput">funct_9</code> can
+ be specified.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_destructor"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_destructor" title="
+ Destructor">
+ Destructor</a>
+</h6></div></div></div>
+<pre class="programlisting">~thread_tuple_once();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ If *this have associateds thread of execution, calls detach() on
+ them. Destroys *this.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_joinable"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_joinable" title="
+ Member function joinables()">
+ Member function <code class="computeroutput">joinables()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">bool joinables() const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Returns:</dt>
+<dd>
+ <code class="computeroutput">true</code> if <code class="computeroutput">*this</code>
+ refers to threads of execution, <code class="computeroutput">false</code>
+ otherwise.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_join"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_join" title="
+ Member function join_all()">
+ Member function <code class="computeroutput">join_all()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void join_all();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">join()</code>
+ on each <code class="computeroutput">boost::thread</code> object in the tuple.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the tuple has terminated.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">boost::thread::join</code> is one of the predefined
+ interruption points, <code class="computeroutput">thread_tuple_once<>::join_all()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.member_function__join_all_until___"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.member_function__join_all_until___" title="Member
+ function join_all_until()">Member
+ function <code class="computeroutput">join_all_until()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">bool join_all_until(const system_time& wait_until);
+template<typename TimeDuration>
+bool join_all_for(TimeDuration const& rel_time);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">timed_join()</code> on each <code class="computeroutput">boost::thread</code>
+ object in the tuple.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the tuple has terminated.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ true if joined.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">boost::thread::timed_join</code> is one of the predefined
+ interruption points, <code class="computeroutput">thread_tuple_once<>::timed_join_all()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.member_function__join_any___"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.member_function__join_any___" title="Member
+ function join_any()">Member
+ function <code class="computeroutput">join_any()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">std::size_t join_any();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">join_first()</code> and the <code class="computeroutput">interrup_all()</code>.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the tuple has terminated.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">boost::thread::join</code> is one of the predefined
+ interruption points, <code class="computeroutput">thread_tuple_once<>::join_all()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.timed_join_first_then_interrupt"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.timed_join_first_then_interrupt" title="
+ Member function timed_join_first_then_interrupt()">
+ Member function <code class="computeroutput">timed_join_first_then_interrupt()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">std::pair<bool,std::size_t> timed_join_first_then_interrupt(
+ const system_time& wait_until);
+template<typename TimeDuration>
+std::pair<bool,std::size_t> timed_join_first_then_interrupt(
+ TimeDuration const& rel_time);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">timed_join_first()</code> and the <code class="computeroutput">interrup_all()</code>.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the tuple has terminated.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ true if joined.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">boost::thread::timed_join</code> is one of the predefined
+ interruption points, <code class="computeroutput">thread_tuple_once<>::timed_join_all()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.detach_all"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.detach_all" title="
+ Member function detach_all()">
+ Member function <code class="computeroutput">detach_all()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void detach_all();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">detach()</code>
+ on each <code class="computeroutput">boost::thread</code> object in the tuple.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_interrupt_all"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_interrupt_all" title="
+ Member function interrupt_all()">
+ Member function <code class="computeroutput">interrupt_all()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void interrupt_all();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">thread::interrupt()</code>
+ on each <code class="computeroutput">boost::thread</code> object in the tuple.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_size"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_class.thread_tuple_once_size" title="
+ Member function size()">
+ Member function <code class="computeroutput">size()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">int size();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Returns:</dt>
+<dd>
+ The number of threads in the tuple.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_make_thread_tuple_once"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_tuple_once_hpp.thread_tuple_once_make_thread_tuple_once" title="
+ Non Member Function make_thread_tuple_once()">
+ Non Member Function <code class="computeroutput">make_thread_tuple_once()</code></a>
+</h5></div></div></div>
+<pre class="programlisting">template<typename F0, ..., typename Fn-1>
+thread_tuple_once make_thread_tuple_once(F0 f0, ..., Fn fn-1);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ makes a new thread_tuple_once<>.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ the created thread tuple.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp" title="
+ Header <boost/interthreads/thread_group_once.hpp>">
+ Header <code class="computeroutput"><boost/interthreads/thread_group_once.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class">
+ Template Class <code class="computeroutput">thread_group_once<></code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_make_thread_group_once">
+ Non Member Function <code class="computeroutput">make_thread_group_once()</code></a></dt>
+</dl></div>
+<pre class="programlisting">namespace boost {
+namespace interthreads {
+
+ template <std::size_t N>
+ class thread_group;
+
+}
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class" title="
+ Template Class thread_group_once<>">
+ Template Class <code class="computeroutput">thread_group_once<></code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_callable_constructor">
+ Constructor</a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_destructor">
+ Destructor</a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_joinable">
+ Member function <code class="computeroutput">joinables()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_join">
+ Member function <code class="computeroutput">join_all()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_timed_join">
+ Member function <code class="computeroutput">join_all_until()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.join_first_then_interrupt">
+ Member function <code class="computeroutput">join_any()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.timed_join_first_then_interrupt">
+ Member function <code class="computeroutput">join_any_until()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.detach_all">
+ Member function <code class="computeroutput">detach_all()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.member_function__interrupt_all___">Member
+ function <code class="computeroutput">interrupt_all()</code></a></dt>
+<dt><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_size">
+ Member function <code class="computeroutput">size()</code></a></dt>
+</dl></div>
+
+ <code class="computeroutput">thread_group_once<></code>
+ is an extension of the boost::thread_group which allows to join the thread
+ finishing the first, using for that the set_once synchronizer.
+ 
+<pre class="programlisting">template <std::size_t n>
+class thread_group_once {
+public:
+ thread_group_once();
+ ~thread_group_once();
+
+ template<typename F>
+ thread* create_thread(F threadfunc);
+ void remove_thread(thread* thrd);
+
+ // move support
+ thread_group_once(boost::move_t<thread_group_once<n>> x);
+ thread_group_once& operator=(boost::move_t<thread_group_once<n>> x);
+ operator boost::move_t<thread_group_once<n>>();
+ boost::move_t<thread_group_once<n>> move();
+
+ void swap(thread_group_once<n>& x);
+
+ bool joinables() const;
+
+ void join_all();
+ bool join_all_until(const system_time& wait_until);
+ template<typename TimeDuration>
+ bool join_all_for(TimeDuration const& rel_time);
+
+ std::size_t join_any();
+ std::pair<bool,std::size_t> join_any_until(
+ const system_time& wait_until);
+ template<typename TimeDuration>
+ std::pair<bool,std::size_t> join_any_for(
+ TimeDuration const& rel_time);
+
+ void detach_all();
+
+ void interrupt_all();
+ bool interruption_requested() const;
+
+ size_t size();
+
+ const thread& operator[](std::size_t i);
+};
+}
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_callable_constructor"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_callable_constructor" title="
+ Constructor">
+ Constructor</a>
+</h6></div></div></div>
+<pre class="programlisting">thread_group_once();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ creates a thread group.
+ </dd>
+<dt>Postconditions:</dt>
+<dd>
+ <code class="computeroutput">*this</code>
+ refers to the newly created group of threads of execution.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::thread_resource_error</code> if an error
+ occurs.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_destructor"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_destructor" title="
+ Destructor">
+ Destructor</a>
+</h6></div></div></div>
+<pre class="programlisting">~thread_group_once();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ If *this have associateds thread of execution, calls detach() on
+ them. Destroys *this.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_joinable"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_joinable" title="
+ Member function joinables()">
+ Member function <code class="computeroutput">joinables()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">bool joinables() const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Returns:</dt>
+<dd>
+ <code class="computeroutput">true</code> if <code class="computeroutput">*this</code>
+ refers to threads of execution, <code class="computeroutput">false</code>
+ otherwise.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_join"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_join" title="
+ Member function join_all()">
+ Member function <code class="computeroutput">join_all()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void join_all();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">join()</code>
+ on each <code class="computeroutput">boost::thread</code> object in the group.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the group has terminated.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">boost::thread::join</code> is one of the predefined
+ interruption points, <code class="computeroutput">thread_group_once<>::join_all()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_timed_join"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_timed_join" title="
+ Member function join_all_until()">
+ Member function <code class="computeroutput">join_all_until()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">bool join_all_until(const system_time& wait_until);
+template<typename TimeDuration>
+bool join_all_for(TimeDuration const& rel_time);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">timed_join()</code> on each <code class="computeroutput">boost::thread</code>
+ object in the group.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the group has terminated.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ true if joined.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">boost::thread::timed_join</code> is one of the predefined
+ interruption points, <code class="computeroutput">thread_group_once<>::timed_join_all()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.join_first_then_interrupt"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.join_first_then_interrupt" title="
+ Member function join_any()">
+ Member function <code class="computeroutput">join_any()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">std::size_t join_any();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">join_any()</code>
+ and the <code class="computeroutput">interrup_all()</code>.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the group has terminated.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">join_any</code>
+ is one of the predefined interruption points, <code class="computeroutput">thread_group_once<>::join_any()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.timed_join_first_then_interrupt"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.timed_join_first_then_interrupt" title="
+ Member function join_any_until()">
+ Member function <code class="computeroutput">join_any_until()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">std::pair<bool,std::size_t> join_any_until(
+ const system_time& wait_until);
+template<typename TimeDuration>
+std::pair<bool,std::size_t> join_any_for(
+ TimeDuration const& rel_time);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">get_until()</code> and the <code class="computeroutput">interrup_all()</code>.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ Every thread in the group has terminated.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ true if joined.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Note:</dt>
+<dd>
+ Since <code class="computeroutput">boost::thread::timed_join</code> is one of the predefined
+ interruption points, <code class="computeroutput">thread_group_once<>::timed_join_all()</code> is also an interruption point.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.detach_all"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.detach_all" title="
+ Member function detach_all()">
+ Member function <code class="computeroutput">detach_all()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void detach_all();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">detach()</code>
+ on each <code class="computeroutput">boost::thread</code> object in the group.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.member_function__interrupt_all___"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.member_function__interrupt_all___" title="Member
+ function interrupt_all()">Member
+ function <code class="computeroutput">interrupt_all()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void interrupt_all();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Call <code class="computeroutput">thread::interrupt()</code>
+ on each <code class="computeroutput">boost::thread</code> object in the group.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_size"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_class.thread_group_once_size" title="
+ Member function size()">
+ Member function <code class="computeroutput">size()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">int size();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Returns:</dt>
+<dd>
+ The number of threads in the group.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_make_thread_group_once"></a><a href="thread_array_reference.html#toward_boost_interthreads.reference.thread_array_reference.thread_group_once_hpp.thread_group_once_make_thread_group_once" title="
+ Non Member Function make_thread_group_once()">
+ Non Member Function <code class="computeroutput">make_thread_group_once()</code></a>
+</h5></div></div></div>
+<pre class="programlisting">template<typename F0, ..., typename Fn-1>
+thread_group_once make_thread_group_once(F0 f0, ..., Fn fn-1);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ makes a new thread_group_once<>.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ the created thread group.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="thread_extensions_reference.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../examples.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference/thread_extensions_reference.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/reference/thread_extensions_reference.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,1424 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Thread
+ Extensions Reference</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../reference.html" title=" Reference">
+<link rel="prev" href="concepts.html" title="Concepts">
+<link rel="next" href="thread_array_reference.html" title="Thread
+ Array Reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="concepts.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="thread_array_reference.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference"></a><a href="thread_extensions_reference.html" title="Thread
+ Extensions Reference">Thread
+ Extensions Reference</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_decoration.hpp></code></a></dt>
+<dd><dl><dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp.thread_decoration">
+ Class <code class="computeroutput">thread_decoration</code></a></dt></dl></dd>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_decorator.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator">
+ Class <code class="computeroutput">thread_decorator</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.decorate">
+ Non Member Function <code class="computeroutput">decorate()</code></a></dt>
+</dl></dd>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_specific_shared_ptr.hpp></code></a></dt>
+<dd><dl><dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr">
+ Template Class <code class="computeroutput">thread_specific_shared_ptr<></code></a></dt></dl></dd>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp">
+ Header <code class="computeroutput"><boost/interthreads/thread_keep_alive.hpp></code></a></dt>
+<dd><dl>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.enable_keep_alive">
+ class <code class="computeroutput">enable_keep_alive</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_disable_keep_alive">
+ class <code class="computeroutput">disable_keep_alive</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_keep_alive_check_point">
+ Non Member Function <code class="computeroutput">keep_alive_check_point()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_keep_alive_enabled">
+ Non Member Function <code class="computeroutput">keep_alive_enabled()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_keep_alive_set_on_dead_thread">
+ Non Member Function <code class="computeroutput">set_on_dead_thread()</code></a></dt>
+</dl></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp" title="
+ Header <boost/interthreads/thread_decoration.hpp>">
+ Header <code class="computeroutput"><boost/interthreads/thread_decoration.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp.thread_decoration">
+ Class <code class="computeroutput">thread_decoration</code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+namespace interthreads {
+ class thread_decoration;
+}
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp.thread_decoration"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp.thread_decoration" title="
+ Class thread_decoration">
+ Class <code class="computeroutput">thread_decoration</code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp.thread_decoration.thread_decoration_class_constructor_setup">
+ Constructor with setup</a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp.thread_decoration.constructor_with_setup___cleanup">Constructor
+ with setup & cleanup</a></dt>
+</dl></div>
+
+ <code class="computeroutput">thread_decoration</code> defines
+ a couple of setup/cleanup functions chained to the last constructed decoration,
+ i.e. decorations are chained between them.
+ 
+<pre class="programlisting">class thread_decoration {
+public:
+ template<typename Callable1>
+ thread_decoration(Callable1 setup);
+
+ template<typename Callable1,typename Callable2>
+ thread_decoration(Callable1 setup, Callable2 cleanup);
+
+ ~thread_decoration() {
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp.thread_decoration.thread_decoration_class_constructor_setup"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp.thread_decoration.thread_decoration_class_constructor_setup" title="
+ Constructor with setup">
+ Constructor with setup</a>
+</h6></div></div></div>
+<pre class="programlisting">template<typename Callable>
+thread_decoration(Callable func);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Requires:</dt>
+<dd>
+ <code class="computeroutput">Callable</code> is <code class="computeroutput">CopyConstructible</code>. Copying <code class="computeroutput">setup</code> shall have no side effects,
+ and the effect of calling the copy shall be equivalent to calling
+ the original.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ <code class="computeroutput">setup</code> is copied
+ into storage managed internally by the library, and that copy is
+ invoked by the <code class="computeroutput">decorate()</code> function.
+ </dd>
+<dt>Postconditions:</dt>
+<dd>
+ <code class="computeroutput">*this</code>
+ refers to a decoration.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ unsafe
+ </dd>
+</dl>
+</div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ The library do not ensures any order of decorations.
+ </td></tr>
+</table></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp.thread_decoration.constructor_with_setup___cleanup"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decoration_hpp.thread_decoration.constructor_with_setup___cleanup" title="Constructor
+ with setup & cleanup">Constructor
+ with setup & cleanup</a>
+</h6></div></div></div>
+<pre class="programlisting">template<typename Callable1,typename Callable2>
+thread_decoration(Callable1 setup, Callable2 cleanup);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Requires:</dt>
+<dd>
+ <code class="computeroutput">Callable1</code> &
+ <code class="computeroutput">Callable1</code> are
+ <code class="computeroutput">CopyConstructible</code>.
+ Copying <code class="computeroutput">setup</code> or
+ <code class="computeroutput">cleanup</code> shall have
+ no side effects, and the effect of calling the copy shall be equivalent
+ to calling the original.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ <code class="computeroutput">setup</code> and <code class="computeroutput">cleanup</code> are copied into storage
+ managed internally by the library, and the <code class="computeroutput">setup</code>
+ copy is invoked by the <code class="computeroutput">decorate()</code> function. If successful the cleanup
+ function is registered to the to the thread exit handler.
+ </dd>
+<dt>Postconditions:</dt>
+<dd>
+ <code class="computeroutput">*this</code>
+ refers to a decoration.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ unsafe
+ </dd>
+</dl>
+</div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ The library do not ensures any order of setup decorations neither
+ of cleanup decorations.
+ </td></tr>
+</table></div>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp" title="
+ Header <boost/interthreads/thread_decorator.hpp>">
+ Header <code class="computeroutput"><boost/interthreads/thread_decorator.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator">
+ Class <code class="computeroutput">thread_decorator</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.decorate">
+ Non Member Function <code class="computeroutput">decorate()</code></a></dt>
+</dl></div>
+<pre class="programlisting">namespace boost {
+namespace interthreads {
+ class thread_decorator;
+ void decorate();
+}
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator" title="
+ Class thread_decorator">
+ Class <code class="computeroutput">thread_decorator</code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_decorate_constructor">
+ Constructor</a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_decorate_constructorn">
+ Constructor</a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_decorate_copy_move_constructor">
+ Copy Move Constructor</a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_decorate_copy_constructor">
+ Assign Move Constructor</a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_conversion">
+ Member Function <code class="computeroutput">operator detail::thread_move_t<thread_decorator>()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_move">
+ Member Function <code class="computeroutput">move()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_swap">
+ Member Function <code class="computeroutput">swap()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_operator_f">
+ Member Function <code class="computeroutput">operator()()</code></a></dt>
+</dl></div>
+
+ <code class="computeroutput">thread_decorator</code> is a
+ functor wrapping a function with the setup and the cleanup of chained
+ decorations which will be called only once by thread: decoration's setup
+ are called before the thread function and decoration's cleanup at thread
+ exit.
+ 
+<pre class="programlisting">class thread_decorator {
+public:
+
+ template <class Callable>
+ explicit thread_decorator(Callable&& f);
+ template <class Callable>
+ explicit thread_decorator(detail::thread_move_t<Callable> f):
+ template<typename Callable>
+ thread_decorator(Callable f,
+ typename disable_if<boost::is_convertible<F&,detail::thread_move_t<F> >
+ , detail::dummy* >::type=0);
+
+ template <typename Callable, typename A1, typename A2, ...>
+ thread_decorator(Callable f, A1 a1, A2 a2, ...)
+
+ thread_decorator(thread_decorator&& other);
+
+ thread_decorator& operator=(thread_decorator&& other);
+
+ thread_decorator&& move();
+
+ void swap(thread_decorator& x);
+
+ void operator ()();
+
+};
+</pre>
+
+ Functor wrapping the user function thread to ensure that all the decorations
+ are called.
+ 
+
+ Objects of type <code class="computeroutput">thread_decorator</code>
+ are movable, so they can be stored in move-aware containers, and returned
+ from functions. This allows the details of thread decoration to be wrapped
+ in a function.
+ 
+<pre class="programlisting">thread_decorator make_decorator();
+
+void f()
+{
+ boot::thread some_thread(make_decorator());
+ some_thread.join();
+}
+</pre>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+
+ On compilers that support rvalue references, <code class="computeroutput">thread_decorator</code>
+ will provides a proper move constructor and move-assignment operator,
+ and therefore meets the C++0x <code class="computeroutput">MoveConstructible</code>
+ and <code class="computeroutput">MoveAssignable</code>
+ concepts. With such compilers, <code class="computeroutput">thread_decorator</code>
+ can therefore be used with containers that support those concepts.
+ 
+
+ For other compilers, move support is provided with a move emulation
+ layer, so containers must explicitly detect that move emulation layer.
+ See <code class="computeroutput"><boost/thread/detail/move.hpp></code> for details.
+ 
+</td></tr>
+</table></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_decorate_constructor"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_decorate_constructor" title="
+ Constructor">
+ Constructor</a>
+</h6></div></div></div>
+<pre class="programlisting">template <class Callable>
+thread_decorator(Callable&& func);
+template<typename Callable>
+thread_decorator(Callable func);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Template parameters:</dt>
+<dd>
+ <code class="computeroutput">Callable</code> must by
+ <code class="computeroutput">CopyConstructible</code>.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ <code class="computeroutput">func</code> is copied
+ into storage managed internally by the library, and that copy will
+ be invoked after the operator() function when the decorate is used
+ as Callable of a newly-created thread of execution.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">std::bad_alloc</code> when resources unavailable.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_decorate_constructorn"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_decorate_constructorn" title="
+ Constructor">
+ Constructor</a>
+</h6></div></div></div>
+<pre class="programlisting">template <typename Callable, typename A1, typename A2, ...>
+thread_decorator(Callable func, A1 a1, A2 a2, ...)
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Template parameters:</dt>
+<dd>
+ <code class="computeroutput">Callable</code> must by
+ <code class="computeroutput">CopyConstructible</code>.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ <code class="computeroutput">func</code> is copied
+ into storage managed internally by the library, and that copy will
+ be invoked after the operator() function when the decorate is used
+ as Callable of a newly-created thread of execution.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">std::bad_alloc</code> when resources unavailable.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe
+ </dd>
+<dt>Limitations:</dt>
+<dd>
+ The current implementation defines overloads up to four parameters.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_decorate_copy_move_constructor"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_decorate_copy_move_constructor" title="
+ Copy Move Constructor">
+ Copy Move Constructor</a>
+</h6></div></div></div>
+<pre class="programlisting">thread_decorator(thread_decorator&& other);
+thread_decorator(detail::thread_move_t<thread_decorator> other) {
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Template parameters:</dt>
+<dd>
+ <code class="computeroutput">Callable</code> must by
+ <code class="computeroutput">CopyConstructible</code>.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ <code class="computeroutput">func</code> is copied
+ into storage managed internally by the library, and that copy will
+ be invoked after the operator() function when the decorate is used
+ as Callable of a newly-created thread of execution.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">std::bad_alloc</code> when resources unavailable.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_decorate_copy_constructor"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_decorate_copy_constructor" title="
+ Assign Move Constructor">
+ Assign Move Constructor</a>
+</h6></div></div></div>
+<pre class="programlisting">thread_decorator& operator=(thread_decorator&& other);
+thread_decorator& operator=(detail::thread_move_t<thread_decorator> x) {
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Requires:</dt>
+<dd>
+ <code class="computeroutput">Callable</code> must by
+ <code class="computeroutput">CopyConstructible</code>.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ <code class="computeroutput">func</code> is copied
+ into storage managed internally by the library, and that copy will
+ be invoked after the operator() function when the decorate is used
+ as Callable of a newly-created thread of execution.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ a reference to <code class="computeroutput">*this</code>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ neutral
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_conversion"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_conversion" title="
+ Member Function operator detail::thread_move_t<thread_decorator>()">
+ Member Function <code class="computeroutput">operator detail::thread_move_t<thread_decorator>()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">operator detail::thread_move_t<thread_decorator>();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ helper for move semantics emulation.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ the move form <code class="computeroutput">*this</code>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ neutral
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_move"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_move" title="
+ Member Function move()">
+ Member Function <code class="computeroutput">move()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">detail::thread_move_t<thread_decorator> move() {
+thread_decorator&& move();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Move *this to the caller.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ the move form <code class="computeroutput">*this</code>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ neutral
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_swap"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_swap" title="
+ Member Function swap()">
+ Member Function <code class="computeroutput">swap()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void swap(thread_decorator& x);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ neutral
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_operator_f"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.thread_decorator.decorator_thread_decoration_operator_f" title="
+ Member Function operator()()">
+ Member Function <code class="computeroutput">operator()()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void operator()();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Functor operator
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Any exception thrown by the decorations or the user function.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ unsafe - depends on the decorations construction/destruction.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.decorate"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_decorator_hpp.decorate" title="
+ Non Member Function decorate()">
+ Non Member Function <code class="computeroutput">decorate()</code></a>
+</h5></div></div></div>
+<pre class="programlisting">void decorate();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Requires:</dt>
+<dd>
+ <code class="computeroutput">Callable</code> is <code class="computeroutput">CopyConstructible</code>. Copying <code class="computeroutput">f</code> shall have no side effects, and
+ the effect of calling the copy shall be equivalent to calling the
+ original.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ Calls every declared decoration using the thread_decoration class.
+ </dd>
+<dt>Postconditions:</dt>
+<dd>
+ All the decorations have been called.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Any exception thrown by the decorations.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ unsafe - depends on the decorations construction/destruction.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp" title="
+ Header <boost/interthreads/thread_specific_shared_ptr.hpp>">
+ Header <code class="computeroutput"><boost/interthreads/thread_specific_shared_ptr.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl><dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr">
+ Template Class <code class="computeroutput">thread_specific_shared_ptr<></code></a></dt></dl></div>
+<pre class="programlisting">namespace boost {
+namespace interthreads {
+
+ template <typename T>
+ class thread_specific_shared_ptr;
+
+}
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr" title="
+ Template Class thread_specific_shared_ptr<>">
+ Template Class <code class="computeroutput">thread_specific_shared_ptr<></code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_reference_parameters">
+ Template parameters</a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_reference_types">
+ Public types</a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_default_constructor">
+ Constructor</a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_constructor_with_custom_cleanup">
+ Cleanup Constructor</a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_destructor">
+ Destructor</a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_get">
+ Member Function <code class="computeroutput">get()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_operator_arrow">
+ Member Function <code class="computeroutput">operator->()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_operator_star">
+ Member Function <code class="computeroutput">operator*()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_reset">
+ Member Function <code class="computeroutput">reset()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_wait_and_get">
+ Member Function <code class="computeroutput">wait_and_get()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_operatora">
+ Member Function <code class="computeroutput">operator[]()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.get_mutex">
+ Member Function <code class="computeroutput">get_mutex()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.get_map">
+ Member Function <code class="computeroutput">get_map()</code></a></dt>
+</dl></div>
+
+ <code class="computeroutput">bith::thread_specific_shared_ptr<></code>
+ is an extension of the thread_specific_ptr providing access to the thread
+ specific context from other threads.
+ 
+<pre class="programlisting">template <typename T>
+class thread_specific_shared_ptr : private noncopyable
+{
+public:
+ typedef shared_ptr<T> shared_ptr_type;
+ typedef 'implementation defined' map_type;
+ typedef 'implementation defined' mutex_type;
+ typedef 'implementation defined' lock_type;
+
+ thread_specific_shared_ptr();
+ explicit thread_specific_shared_ptr(void (*cleanup_)(shared_ptr_type));
+ ~thread_specific_shared_ptr();
+
+ T* get() const;
+ T* operator->() const;
+ T& operator*() const;
+ void reset();
+ template<class Y>
+ void reset(Y * p);
+ template<class Y, class D>
+ void reset(Y * p, D d);
+ template<class Y, class D, class A>
+ void reset(Y * p, D d, A a);
+
+ mutex_type& get_mutex();
+ const map_type& get_map(lock_type&) const;
+ shared_ptr_type operator[](thread::id id) const;
+ shared_ptr_type wait_and_get(thread::id id) const;
+private:
+ shared_ptr_type get_shared_ptr() const;
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_reference_parameters"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_reference_parameters" title="
+ Template parameters">
+ Template parameters</a>
+</h6></div></div></div>
+
+ <code class="computeroutput">thread_specific_shared_ptr<></code> is instantiated with the following
+ types:
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ T The type of the pointeed object
+ </li></ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_reference_types"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_reference_types" title="
+ Public types">
+ Public types</a>
+</h6></div></div></div>
+
+ <code class="computeroutput">thread_specific_shared_ptr<></code> defines the following types:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+<code class="computeroutput">shared_ptr_type</code>
+ The shared pointed type.
+ </li>
+<li>
+<code class="computeroutput">map_type</code>
+ The mapping type from <code class="computeroutput">thread::id</code>
+ to <code class="computeroutput">shared_ptr_type</code>
+</li>
+<li>
+<code class="computeroutput">mutex_type</code>
+ The protecting mutext type follwing the Lockable Concept
+ </li>
+<li>
+<code class="computeroutput">lock_type</code>
+ The lock used to get the map follwing the unique_lock subjacent Concept
+ </li>
+</ul></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_default_constructor"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_default_constructor" title="
+ Constructor">
+ Constructor</a>
+</h6></div></div></div>
+<pre class="programlisting">thread_specific_shared_ptr();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Construct a <code class="computeroutput">thread_specific_shared_ptr<></code> object for storing a pointer
+ to an object of type <code class="computeroutput">T</code>
+ specific to each thread.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">std::bad_alloc</code> when resources unavailable.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_constructor_with_custom_cleanup"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_constructor_with_custom_cleanup" title="
+ Cleanup Constructor">
+ Cleanup Constructor</a>
+</h6></div></div></div>
+<pre class="programlisting">explicit thread_specific_shared_ptr(void (*cleanup_)(shared_ptr_type));
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Requires:</dt>
+<dd>
+ <code class="computeroutput">cleanup_function(this->get())</code> does not throw any exceptions.
+ </dd>
+<dt>Effects:</dt>
+<dd>
+ Construct a <code class="computeroutput">thread_specific_shared_ptr<></code> object for storing a pointer
+ to an object of type <code class="computeroutput">T</code>
+ specific to each thread. The supplied <code class="computeroutput">cleanup_function</code>
+ will be called at thread exit.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">std::bad_alloc</code> when resources unavailable.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_destructor"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_destructor" title="
+ Destructor">
+ Destructor</a>
+</h6></div></div></div>
+<pre class="programlisting">~thread_specific_shared_ptr();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Remove from the static map the current thread::id and destroys
+ <code class="computeroutput">*this</code>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe.
+ </dd>
+</dl>
+</div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ Care needs to be taken to ensure that any threads still running after
+ an instance of <code class="computeroutput">boost::thread_specific_shared_ptr<></code> has been destroyed do not
+ call any member functions on that instance. Is for this raison that
+ usualy instance of this class are static.
+ </td></tr>
+</table></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_get"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_get" title="
+ Member Function get()">
+ Member Function <code class="computeroutput">get()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">shared_ptr_type get() const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Returns:</dt>
+<dd>
+ The pointer associated with the current thread.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe.
+ </dd>
+</dl>
+</div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ The initial value associated with an instance of <code class="computeroutput">boost::thread_specific_shared_ptr<></code> is <code class="computeroutput">0</code>
+ for each thread.
+ </td></tr>
+</table></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_operator_arrow"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_operator_arrow" title="
+ Member Function operator->()">
+ Member Function <code class="computeroutput">operator->()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">T* operator->() const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Requires:</dt>
+<dd>
+ <code class="computeroutput">this->get()</code>
+ is not <code class="computeroutput">0</code>.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ <code class="computeroutput">this->get()</code>
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_operator_star"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_operator_star" title="
+ Member Function operator*()">
+ Member Function <code class="computeroutput">operator*()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">T& operator*() const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Requires:</dt>
+<dd>
+ <code class="computeroutput">this->get()</code>
+ is not <code class="computeroutput">0</code>.
+ </dd>
+<dt>Returns:</dt>
+<dd>
+ <code class="computeroutput">*(this->get())</code>
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_reset"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_reset" title="
+ Member Function reset()">
+ Member Function <code class="computeroutput">reset()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">void reset();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Equivalent to <code class="computeroutput">shared_ptr().swap(this->get_shared_ptr())</code>. Update the mapping.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ <code class="computeroutput">this->get()==0</code>
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">std::bad_alloc</code> when resources unavailable.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe.
+ </dd>
+</dl>
+</div>
+<pre class="programlisting">template<class Y> void reset(Y * new_value);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Equivalent to <code class="computeroutput">shared_ptr(new_value).swap(this->get_shared_ptr())</code>. Update the mapping.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ <code class="computeroutput">this->get()==new_value</code>
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">std::bad_alloc</code> when resources unavailable.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe.
+ </dd>
+</dl>
+</div>
+<pre class="programlisting">template<class Y, class D> void reset(Y * new_value, D deleter);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Equivalent to <code class="computeroutput">shared_ptr(new_value, deleter).swap(this->get_shared_ptr())</code>. Update the mapping.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ <code class="computeroutput">this->get()==new_value</code>
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">std::bad_alloc</code> when resources unavailable.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe.
+ </dd>
+</dl>
+</div>
+<pre class="programlisting">template<class Y, class D, class A> void reset(Y * new_value, D deleter, A a);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Equivalent to <code class="computeroutput">shared_ptr(new_value, deleter, a).swap(this->get_shared_ptr())</code>. Update the mapping.
+ </dd>
+<dt>Postcondition:</dt>
+<dd>
+ <code class="computeroutput">this->get()==new_value</code>
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">std::bad_alloc</code> when resources unavailable.
+ </dd>
+<dt>Thread safety:</dt>
+<dd>
+ safe.
+ </dd>
+</dl>
+</div>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ If <code class="computeroutput">this->get()!=new_value</code> and <code class="computeroutput">this->get()</code> is non-<code class="computeroutput">NULL</code>,
+ invoke <code class="computeroutput">delete this->get()</code> or <code class="computeroutput">deleter(this->get())</code> as appropriate. Store <code class="computeroutput">new_value</code> as the pointer associated
+ with the current thread.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_wait_and_get"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_wait_and_get" title="
+ Member Function wait_and_get()">
+ Member Function <code class="computeroutput">wait_and_get()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">shared_ptr_type wait_and_get(thread::id id) const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Waits until the specific shared pointer has been set and returns
+ a shared pointer to this context.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ <code class="computeroutput">boost::thread_interrupted</code> if the current
+ thread of execution is interrupted.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_operatora"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.thread_specific_shared_ptr_operatora" title="
+ Member Function operator[]()">
+ Member Function <code class="computeroutput">operator[]()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">shared_ptr_type operator[](thread::id id) const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns a copy of the specific shared_ptr of the thread of execution
+ identified by the <code class="computeroutput">thread::id</code>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.get_mutex"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.get_mutex" title="
+ Member Function get_mutex()">
+ Member Function <code class="computeroutput">get_mutex()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">mutex_type& get_mutex();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns a reference to the protection mutex.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.get_map"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.thread_specific_shared_ptr_hpp.thread_specific_shared_ptr_reference_thread_specific_shared_ptr.get_map" title="
+ Member Function get_map()">
+ Member Function <code class="computeroutput">get_map()</code></a>
+</h6></div></div></div>
+<pre class="programlisting">const map_type& get_map(lock_type&) const;
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Returns a reference to the mapping from <code class="computeroutput">thread::id</code>
+ to the specific pointers provided the user gives a lock on the
+ motext get using <code class="computeroutput">get_mutex()</code>.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing.
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp" title="
+ Header <boost/interthreads/thread_keep_alive.hpp>">
+ Header <code class="computeroutput"><boost/interthreads/thread_keep_alive.hpp></code></a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.enable_keep_alive">
+ class <code class="computeroutput">enable_keep_alive</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_disable_keep_alive">
+ class <code class="computeroutput">disable_keep_alive</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_keep_alive_check_point">
+ Non Member Function <code class="computeroutput">keep_alive_check_point()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_keep_alive_enabled">
+ Non Member Function <code class="computeroutput">keep_alive_enabled()</code></a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_keep_alive_set_on_dead_thread">
+ Non Member Function <code class="computeroutput">set_on_dead_thread()</code></a></dt>
+</dl></div>
+
+ Includes the keep alive enabling/disabling classes and non member functions.
+ 
+<pre class="programlisting">namespace boost {
+namespace interthreads {
+ namespace this_thread {
+ class enable_keep_alive;
+ class disable_keep_alive;
+
+ void keep_alive_check_point();
+ bool keep_alive_enabled();
+ typedef void (*on_dead_thread_type)(thread::id);
+ void set_on_dead_thread(on_dead_thread_type fct);
+ }
+}
+}
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.enable_keep_alive"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.enable_keep_alive" title="
+ class enable_keep_alive">
+ class <code class="computeroutput">enable_keep_alive</code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.enable_keep_alive.keep_alive_enable_keep_alive_Constructor">
+ Constructor</a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.enable_keep_alive.keep_alive_enable_keep_alive_Destructor">
+ Destructor</a></dt>
+</dl></div>
+
+ Keep alive enabler.
+ 
+<pre class="programlisting">class enable_keep_alive : private noncopyable{
+public:
+ enable_keep_alive(std::size_t threshold=2, std::size_t tap=1);
+ ~enable_keep_alive();
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.enable_keep_alive.keep_alive_enable_keep_alive_Constructor"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.enable_keep_alive.keep_alive_enable_keep_alive_Constructor" title="
+ Constructor">
+ Constructor</a>
+</h6></div></div></div>
+<pre class="programlisting">enable_keep_alive(std::size_t threshold=2, std::size_t tap=1);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Enable the keep alive mechanism on this thread of execution.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.enable_keep_alive.keep_alive_enable_keep_alive_Destructor"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.enable_keep_alive.keep_alive_enable_keep_alive_Destructor" title="
+ Destructor">
+ Destructor</a>
+</h6></div></div></div>
+<pre class="programlisting">~enable_keep_alive();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Restore the keep alive mechanism as it was before the constructor.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_disable_keep_alive"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_disable_keep_alive" title="
+ class disable_keep_alive">
+ class <code class="computeroutput">disable_keep_alive</code></a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_disable_keep_alive.keep_alive_disable_keep_alive_Constructor">
+ Constructor</a></dt>
+<dt><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_disable_keep_alive.keep_alive_disable_keep_alive_Destructor">
+ Destructor</a></dt>
+</dl></div>
+
+ Keep alive disabler.
+ 
+<pre class="programlisting">class disable_keep_alive private noncopyable {
+public:
+ disable_keep_alive();
+ ~disable_keep_alive();
+};
+</pre>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_disable_keep_alive.keep_alive_disable_keep_alive_Constructor"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_disable_keep_alive.keep_alive_disable_keep_alive_Constructor" title="
+ Constructor">
+ Constructor</a>
+</h6></div></div></div>
+<pre class="programlisting">disable_keep_alive();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Disable the keep alive mechanism on this thread of execution.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_disable_keep_alive.keep_alive_disable_keep_alive_Destructor"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_disable_keep_alive.keep_alive_disable_keep_alive_Destructor" title="
+ Destructor">
+ Destructor</a>
+</h6></div></div></div>
+<pre class="programlisting">~disable_keep_alive();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Restore the keep alive mechanism as it was before the constructor.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_keep_alive_check_point"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_keep_alive_check_point" title="
+ Non Member Function keep_alive_check_point()">
+ Non Member Function <code class="computeroutput">keep_alive_check_point()</code></a>
+</h5></div></div></div>
+
+ Keep alive check point.
+ 
+<pre class="programlisting">void keep_alive_check_point();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ States that the current thread is alive.
+ </dd>
+<dt>Postconditions:</dt>
+<dd>
+ The thread is alive.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_keep_alive_enabled"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_keep_alive_enabled" title="
+ Non Member Function keep_alive_enabled()">
+ Non Member Function <code class="computeroutput">keep_alive_enabled()</code></a>
+</h5></div></div></div>
+
+ Keep alive query.
+ 
+<pre class="programlisting">bool keep_alive_enabled();
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ States if the keep alive mechanism is enabled on this thread.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_keep_alive_set_on_dead_thread"></a><a href="thread_extensions_reference.html#toward_boost_interthreads.reference.thread_extensions_reference.keep_alive_file_hpp.keep_alive_keep_alive_set_on_dead_thread" title="
+ Non Member Function set_on_dead_thread()">
+ Non Member Function <code class="computeroutput">set_on_dead_thread()</code></a>
+</h5></div></div></div>
+
+ Keep alive on dead thread action setting.
+ 
+<pre class="programlisting">void set_on_dead_thread(on_dead_thread_type fct);
+</pre>
+<div class="variablelist">
+
+<dl>
+<dt>Effects:</dt>
+<dd>
+ Modifies the action to be done when a this thread is declared dead.
+ </dd>
+<dt>Throws:</dt>
+<dd>
+ Nothing
+ </dd>
+</dl>
+</div>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="concepts.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="thread_array_reference.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,67 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Users'Guide</title>
+<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../index.html" title="Toward Boost.InterThreads">
+<link rel="prev" href="overview/motivation.html" title=" Motivation">
+<link rel="next" href="users_guide/getting_started.html" title="
+ Getting Started">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="overview/motivation.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="users_guide/getting_started.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="toward_boost_interthreads.users_guide"></a> Users'Guide
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><a href="users_guide/getting_started.html">
+ Getting Started</a></dt>
+<dd><dl>
+<dt><a href="users_guide/getting_started.html#toward_boost_interthreads.users_guide.getting_started.install">
+ Installing InterThreads</a></dt>
+<dt><a href="users_guide/getting_started.html#toward_boost_interthreads.users_guide.getting_started.hello_world__decorator">Hello
+ World! decorator</a></dt>
+<dt><a href="users_guide/getting_started.html#toward_boost_interthreads.users_guide.getting_started.monotonic_thread_id">Monotonic
+ Thread Id</a></dt>
+<dt><a href="users_guide/getting_started.html#toward_boost_interthreads.users_guide.getting_started.basic_keep_alive">Basic
+ keep alive</a></dt>
+</dl></dd>
+<dt> Tutorial</dt>
+<dd><dl><dt><a href="users_guide/tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions">Thread
+ Extensions</a></dt></dl></dd>
+<dt><a href="users_guide/bibliography.html">
+ References</a></dt>
+<dt> Glossary</dt>
+</dl></div>
+
+ [/
+ 
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="overview/motivation.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="users_guide/getting_started.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/bibliography.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/bibliography.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,55 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>
+ References</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../users_guide.html" title=" Users'Guide">
+<link rel="prev" href="tutorial.html" title=" Tutorial">
+<link rel="next" href="glosary.html" title=" Glossary">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tutorial.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../users_guide.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="glosary.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.users_guide.bibliography"></a><a href="bibliography.html" title="
+ References">
+ References</a>
+</h3></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt><a href="http://www.boost.org/libs/thread" target="_top">Boost.Thread
+ (A. Williams)</a></dt>
+<dd>
+ </dd>
+</dl>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="tutorial.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../users_guide.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="glosary.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/getting_started.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/getting_started.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,389 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>
+ Getting Started</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../users_guide.html" title=" Users'Guide">
+<link rel="prev" href="../users_guide.html" title=" Users'Guide">
+<link rel="next" href="tutorial.html" title=" Tutorial">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../users_guide.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../users_guide.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tutorial.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.users_guide.getting_started"></a><a href="getting_started.html" title="
+ Getting Started">
+ Getting Started</a>
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.install">
+ Installing InterThreads</a></dt>
+<dt><a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.hello_world__decorator">Hello
+ World! decorator</a></dt>
+<dt><a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.monotonic_thread_id">Monotonic
+ Thread Id</a></dt>
+<dt><a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.basic_keep_alive">Basic
+ keep alive</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.users_guide.getting_started.install"></a><a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.install" title="
+ Installing InterThreads">
+ Installing InterThreads</a>
+</h4></div></div></div>
+<a name="toward_boost_interthreads.users_guide.getting_started.install.getting_boost_interthreads"></a><h5>
+<a name="id4759283"></a>
+ <a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.install.getting_boost_interthreads">Getting
+ Boost.InterThreads</a>
+ </h5>
+
+ You can get the last stable release of Boost.InterThreads
+ by downloading <code class="literal">interthreads.zip</code> from the <a href="http://www.boost-consulting.com/vault/index.php?directory=Concurrent%20Programming" target="_top">Boost
+ Vault</a>
+ 
+
+ You can also access the latest (unstable?) state from the <a href="https://svn.boost.org/svn/boost/sandbox/interthreads" target="_top">Boost
+ Sandbox</a>.
+ 
+<a name="toward_boost_interthreads.users_guide.getting_started.install.building_boost_interthreads"></a><h5>
+<a name="id4759339"></a>
+ <a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.install.building_boost_interthreads">Building
+ Boost.InterThreads</a>
+ </h5>
+
+ Boost.InterThreads is not a header only
+ library. You need to compile it before use.
+ 
+<pre class="programlisting">cd libs/interthreads/build
+bjam
+</pre>
+<a name="toward_boost_interthreads.users_guide.getting_started.install.build_requirements"></a><h5>
+<a name="id4759412"></a>
+ <a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.install.build_requirements">Build
+ Requirements</a>
+ </h5>
+
+ Boost.InterThreads depends on Boost. You
+ must use either Boost version 1.38.x or the version in SVN trunk. In particular,
+ Boost.InterThreads depends on:
+ 
+<div class="variablelist">
+
+<dl>
+<dt>Boost.Array</dt>
+<dd>
+ for array, ...
+ </dd>
+<dt>Boost.Bind</dt>
+<dd>
+ for bind, ...
+ </dd>
+<dt>Boost.Config</dt>
+<dd>
+ for ??? and abi_prefic_sufix, ...
+ </dd>
+<dt>Boost.Function</dt>
+<dd>
+ for function, ...
+ </dd>
+<dt>Boost.Fusion</dt>
+<dd>
+ for tuples, and sequence algorithms ...
+ </dd>
+<dt>Boost.MPL</dt>
+<dd>
+ for transform, ...
+ </dd>
+<dt>Boost.Preprocesor</dt>
+<dd>
+ to simulate variadic templates , ...
+ </dd>
+<dt>Boost.SmartPtr</dt>
+<dd>
+ for shared_ptr, ...
+ </dd>
+<dt>Boost.Threads</dt>
+<dd>
+ for thread, thread_specific_ptr, call_once, mutex, condition_variable,
+ ...
+ </dd>
+<dt>Boost.TypeOf</dt>
+<dd>
+ to register the ACT types.
+ </dd>
+<dt>Boost.TypeTrais</dt>
+<dd>
+ for is_void, remove_references, ...
+ </dd>
+<dt>Boost.Utility</dt>
+<dd>
+ for result_of, enable_if...
+ </dd>
+</dl>
+</div>
+<a name="toward_boost_interthreads.users_guide.getting_started.install.exceptions_safety"></a><h5>
+<a name="id4759694"></a>
+ <a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.install.exceptions_safety">Exceptions
+ safety</a>
+ </h5>
+
+ All functions in the library are exception-neutral and provide strong guarantee
+ of exception safety as long as the underlying parameters provide it.
+ 
+<a name="toward_boost_interthreads.users_guide.getting_started.install.thread_safety"></a><h5>
+<a name="id4759722"></a>
+ <a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.install.thread_safety">Thread
+ safety</a>
+ </h5>
+
+ All functions in the library are thread-unsafe except when noted explicitly.
+ 
+<a name="toward_boost_interthreads.users_guide.getting_started.install.tested_compilers"></a><h5>
+<a name="id4759749"></a>
+ <a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.install.tested_compilers">Tested
+ compilers</a>
+ </h5>
+
+ Currently, Boost.InterThreads has been
+ tested in the following compilers/platforms:
+ 
+<div class="itemizedlist"><ul type="disc">
+<li>
+ GCC 3.4.4 Cygwin
+ </li>
+<li>
+ GCC 3.4.6 Linux
+ </li>
+<li>
+ GCC 4.1.2 Linux
+ </li>
+</ul></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/html/images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+ Please send any questions, comments and bug reports to boost <at>
+ lists <dot> boost <dot> org.
+ </td></tr>
+</table></div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.users_guide.getting_started.hello_world__decorator"></a><a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.hello_world__decorator" title="Hello
+ World! decorator">Hello
+ World! decorator</a>
+</h4></div></div></div>
+
+ This is a little bit more than a Hello World! example. It will also say
+ Bye, Bye!
+ 
+<pre class="programlisting">#include <boost/interthreads/thread_decorator.hpp>
+#include <boost/thread.hpp>
+#include <iostream>
+
+namespace bith = boost::interthreads;
+
+void my_setup() {
+ std::cout << "Hello World!" << std::endl;
+}
+
+void my_cleanup() {
+ std::cout << "Bye, Bye!" << std::endl;
+}
+
+bith::thread_decoration my_decoration(my_setup, my_cleanup);
+
+void my_thread() {
+ std::cout << "..." << std::endl;
+}
+
+int main() {
+ boost::thread th(bith::make_decorator(my_thread));
+ th.join();
+ return 0;
+}
+</pre>
+
+ When <code class="computeroutput">th</code> is created with
+ the <code class="computeroutput">bith::thread_decorator</code> wrapper, it will initialize
+ all the decorations before calling <code class="computeroutput">my_thread</code>.
+ This <code class="computeroutput">my_cleanup</code> will be
+ registered with the <code class="computeroutput">boost:this_thread::at_thread_exit</code>
+ if the <code class="computeroutput">my_setup</code> function
+ succeeds i.e. does not throw. Then the thread function <code class="computeroutput">my_thread</code>
+ is called. At the thread exit, the <code class="computeroutput">my_cleanup</code>
+ function is called. This results on the following output
+ 
+<pre class="programlisting">Hello World!
+...
+Bye, Bye!
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.users_guide.getting_started.monotonic_thread_id"></a><a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.monotonic_thread_id" title="Monotonic
+ Thread Id">Monotonic
+ Thread Id</a>
+</h4></div></div></div>
+
+ This example use thread decorator and thread specific pointers to implement
+ a monotonic thread identifier.
+ 
+
+ The monotonic thread identifier is managed by the mono_thread_id class.
+ There is a mutex protecting the access to the monotonic counter. The main
+ difference between a thread_specific_shared_ptr and a thread_specific_ptr
+ is that we can get the specific pointer of another thread (*) With the
+ help of bith::thread_decoration, the setting of the thread specific shared
+ pointer is done transparently, as far as the thread is created using a
+ thread decorator. This setup function resets the specific pointer with
+ the value of the monotonic counter which will be self increased.
+ 
+<pre class="programlisting">#include <boost/interthreads/thread_decorator.hpp>
+#include <boost/interthreads/thread_specific_shared_ptr.hpp>
+#include <boost/thread.hpp>
+#include <iostream>
+
+namespace bith = boost::interthreads;
+
+class mono_thread_id {
+ static bith::thread_decoration decoration_;
+ typedef bith::thread_specific_shared_ptr<unsigned> tssp_type;
+ static tssp_type current_;
+ static unsigned counter_;
+ static boost::mutex sync_;
+
+ static unsigned create() {
+ boost::lock_guard<boost::mutex> lock(sync_);
+ unsigned res = counter_;
+ ++counter;
+ return res;
+ }
+ static void setup() {
+ current_.reset(new unsigned(create());
+ }
+public:
+ static unsigned id() {
+ return *current_;
+ }
+ static unsigned id(boost::thread::id id) {
+ return *current_[id]; // (*)
+ }
+
+};
+
+bith::thread_decoration mono_thread_id::decoration(mono_thread_id::setup);
+mono_thread_id::tssp_type mono_thread_id::current_;
+unsigned mono_thread_id::counter_=0;
+boost::mutex mono_thread_id::sync_;
+</pre>
+
+ In this way the applications using the thread_decorator can have access
+ to a monotonic thread id mono_thread_id::id() and this id is accesible
+ to other threads providing the boost::thread::id.
+ 
+<pre class="programlisting">void my_thread() {
+ std::cout << "mono_thread_id=" << mono_thread_id::id() << std::endl;
+ sleep(5);
+}
+
+struct mono_thread_id_out {
+ template<typename T>
+ void operator()(T& t) const {
+ std::cout << "thread::id=" << t.get_id()
+ << " mono_thread_id=" << mono_thread_id::id(t.get_id())
+ << std::endl;
+ }
+};
+
+int main() {
+ bith::shared_threader_decorator ae;
+ BOOST_AUTO(handles, bith::fork_all(basic_threader_decorator, my_thread, my_thread));
+ boost::fusion::for_each(handles, mono_thread_id_out());
+ bith.join_all();
+ return 0;
+}
+</pre>
+
+ This results on the following output
+ 
+<pre class="programlisting">mono_thread_id=1
+mono_thread_id=2
+thread::id=xxxx mono_thread_id=1
+thread::id=xxxx mono_thread_id=2
+
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.users_guide.getting_started.basic_keep_alive"></a><a href="getting_started.html#toward_boost_interthreads.users_guide.getting_started.basic_keep_alive" title="Basic
+ keep alive">Basic
+ keep alive</a>
+</h4></div></div></div>
+
+ This example shows the keep_alive basics.
+ 
+<pre class="programlisting">#include <boost/interthreads/thread_decorator.hpp>
+#include <boost/interthreads/keep_alive.hpp>
+#include <boost/thread/thread.hpp>
+#include <iostream>
+
+namespace bith = boost::interthreads;
+
+void my_thread() {
+ bith::this_thread::enable_keep_alive enabler;
+ for (int i=0; i<5; i++) {
+ bith::this_thread::keep_alive_point();
+ std::cout << "thread_id=" << boost::this_thread::get_id() << std::endl;
+ sleep(1);
+ }
+}
+
+int main() {
+ bith::shared_threader_decorator ae;
+ bith::wait_for_all(ae, my_thread, my_thread, my_thread, my_thread);
+
+ return 0;
+}
+</pre>
+
+ The user creates 4 threads using the shared_threader_decorator <code class="computeroutput">AsynchronousExecutor</code> to be able to use
+ the keep_alive mechanism. It uses the default enabler (one keep_alive_point
+ every 2 seconds).
+ 
+
+ This results on the following output
+ 
+<pre class="programlisting"></pre>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="../users_guide.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../users_guide.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="tutorial.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/glosary.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/glosary.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,91 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Glossary</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../users_guide.html" title=" Users'Guide">
+<link rel="prev" href="bibliography.html" title="
+ References">
+<link rel="next" href="../reference.html" title=" Reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="bibliography.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../users_guide.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../reference.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.users_guide.glosary"></a> Glossary
+</h3></div></div></div>
+<div class="variablelist">
+
+<dl>
+<dt>alive (thread)</dt>
+<dd>
+ a thread is considered alive when not dead.
+ </dd>
+<dt>cleanup decoration</dt>
+<dd>
+ function called at thread exit.
+ </dd>
+<dt>dead (thread)</dt>
+<dd>
+ a thread is considered dead when has not done enough keep alive check
+ points for a given duration.
+ </dd>
+<dt>decoration</dt>
+<dd>
+ Couple of setup/cleanup thread decorating functions.
+ </dd>
+<dt>decorator</dt>
+<dd>
+ Functor wrapper decorating a thread with all the setups and cleanups
+ decorations.
+ </dd>
+<dt>deleter TSSS</dt>
+<dd>
+ specific function used to delete the TSSS.
+ </dd>
+<dt>KA</dt>
+<dd>
+ Keep Alive.
+ </dd>
+<dt>setup decoration</dt>
+<dd>
+ function called before the thread starts.
+ </dd>
+<dt>TSS</dt>
+<dd>
+ Thread Specific Storage.
+ </dd>
+<dt>TSSS</dt>
+<dd>
+ Thread Specific Shared Storage.
+ </dd>
+</dl>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="bibliography.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../users_guide.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="../reference.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Added: sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/tutorial.html
==============================================================================
--- (empty file)
+++ sandbox/interthreads/libs/interthreads/doc/html/toward_boost_interthreads/users_guide/tutorial.html 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -0,0 +1,1019 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title> Tutorial</title>
+<link rel="stylesheet" href="../../../../../../doc/html/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.69.1">
+<link rel="start" href="../../index.html" title="Toward Boost.InterThreads">
+<link rel="up" href="../users_guide.html" title=" Users'Guide">
+<link rel="prev" href="getting_started.html" title="
+ Getting Started">
+<link rel="next" href="bibliography.html" title="
+ References">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table cellpadding="2" width="100%"><tr>
+<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
+<td align="center">Home</td>
+<td align="center">Libraries</td>
+<td align="center">People</td>
+<td align="center">FAQ</td>
+<td align="center">More</td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="getting_started.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../users_guide.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="bibliography.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial"></a> Tutorial
+</h3></div></div></div>
+<div class="toc"><dl>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions">Thread
+ Extensions</a></dt>
+<dd><dl>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator">Thread
+ Decorator</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer">Thread
+ Specific Shared Pointer</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive">Keep
+ alive</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple">Thread
+ Tuple</a></dt>
+</dl></dd>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions" title="Thread
+ Extensions">Thread
+ Extensions</a>
+</h4></div></div></div>
+<div class="toc"><dl>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator">Thread
+ Decorator</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer">Thread
+ Specific Shared Pointer</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive">Keep
+ alive</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple">Thread
+ Tuple</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator" title="Thread
+ Decorator">Thread
+ Decorator</a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator.declaring_a_decoration">Declaring
+ a decoration</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator.creating_threads_with_decorators">Creating
+ threads with decorators</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator.decorator_explicit_call">
+ Calling explictly the decoration on a thread</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator.declaring_a_decoration"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator.declaring_a_decoration" title="Declaring
+ a decoration">Declaring
+ a decoration</a>
+</h6></div></div></div>
+
+ Objects of type <code class="computeroutput">thread_decoration</code>
+ are usualy static and initialized with a <code class="computeroutput">Callable</code>
+ object:
+ 
+<pre class="programlisting">static boost::interthreads::thread_decoration d;
+void setup();
+
+bith::thread_decoration d(setup);
+</pre>
+
+ These decorations will be called either when we request this explicitly
+ at the initialization of the thread (this is needed on the main thread)
+ or when we create a thread using specific decorator wrapper. This is
+ explained in more detail in the next sections.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator.creating_threads_with_decorators"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator.creating_threads_with_decorators" title="Creating
+ threads with decorators">Creating
+ threads with decorators</a>
+</h6></div></div></div>
+
+ When we want the decorations to decorate one thread of execution we
+ can create the thread using the decorator wrapper.
+ 
+<pre class="programlisting">boost::thread th(bith::thread_decorator(fct));
+</pre>
+
+ or using one of the <code class="computeroutput">AsynchronousExecutor</code>
+ decorators, as
+ 
+<pre class="programlisting">bith::basic_threader_decorator ae;
+BOOST_AUTO(th, bith::fork(ae, fct));
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator.decorator_explicit_call"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_decorator.decorator_explicit_call" title="
+ Calling explictly the decoration on a thread">
+ Calling explictly the decoration on a thread</a>
+</h6></div></div></div>
+
+ For threads that are not created using the boost::thread class, as
+ it is the case of the main thread, we need to call explicitly the function
+ <code class="computeroutput">bith::decorate</code> at the begining of the thread.
+ 
+<pre class="programlisting">int main() {
+ bith::decorate();
+ // ...
+}
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer" title="Thread
+ Specific Shared Pointer">Thread
+ Specific Shared Pointer</a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.key_initialization">Key
+ initialization</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.context_initialization">Context
+ initialization</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.obtain_the_pointer_to_the_thread_specific_object_on_the_current_thread">Obtain
+ the pointer to the thread-specific object on the current thread</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.obtain_the_pointer_to_the_thread_specific_object_of_another_thread">Obtain
+ the pointer to the thread-specific object of another thread</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.iterating_through_all_the_thread_specific_context">Iterating
+ through all the thread specific context</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.deleting_the_context">Deleting
+ the context</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.cleanup_at_thread_exit">Cleanup
+ at thread exit</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.key_initialization"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.key_initialization" title="Key
+ initialization">Key
+ initialization</a>
+</h6></div></div></div>
+
+ As the curent implementation uses the address of the thread_specific_shared_ptr<>
+ object, there is no need to do anything to get the key.
+ 
+<pre class="programlisting">bith::thread_specific_shared_ptr<myclass> ptr;
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.context_initialization"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.context_initialization" title="Context
+ initialization">Context
+ initialization</a>
+</h6></div></div></div>
+
+ Initially the pointer has a value of <code class="computeroutput">0</code>
+ in each thread, but the value for the current thread can be set using
+ the <code class="computeroutput">reset()</code>
+ member functions.
+ 
+
+ If the value of the pointer for the current thread is changed using
+ <code class="computeroutput">reset()</code>,
+ then the previous value is destroyed by calling the deleter routine.
+ Alternatively, the stored value can be reset to <code class="computeroutput">0</code>
+ and the prior value returned by calling the <code class="computeroutput">release()</code> member function, allowing the application
+ to take back responsibility for destroying the object.
+ 
+
+ Initialization can be done
+ 
+<div class="itemizedlist"><ul type="disc"><li>
+ explicitly on the curret thread. Basically it works like a thread
+ local storage from inside the thread.
+ </li></ul></div>
+<pre class="programlisting">bith::thread_specific_shared_ptr<myclass> ptr;
+void func() { // current thread
+ // ...
+ ptr.reset(p);
+ // ...
+}
+</pre>
+<div class="itemizedlist"><ul type="disc"><li>
+ When we associate a thread decoration to the thread_specific_shared_ptr<>
+ we initialize implicitly every thread created with a thread_decorator.
+ </li></ul></div>
+<pre class="programlisting">bith::thread_specific_shared_ptr<myclass> ptr;
+void myclass_setup() {
+ ptr.reset(new myclass(any specific parameters));
+}
+bith::thread_decoration myclass_decoration(myclass_setup);
+
+void func() { // ptr.reset(p); done implicitly
+
+}
+
+boost::thread th=bith::make_decorated_thread(func);
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.obtain_the_pointer_to_the_thread_specific_object_on_the_current_thread"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.obtain_the_pointer_to_the_thread_specific_object_on_the_current_thread" title="Obtain
+ the pointer to the thread-specific object on the current thread">Obtain
+ the pointer to the thread-specific object on the current thread</a>
+</h6></div></div></div>
+
+ All functions known from boost::thread_specific_ptr are available except
+ the release function. The value for the current thread can be obtained
+ using the <code class="computeroutput">get()</code>
+ member function, or by using the <code class="computeroutput">*</code>
+ and <code class="computeroutput">-></code> pointer deference
+ operators.
+ 
+<pre class="programlisting">void func() {
+{ // current thread
+ // ...
+ if (ptr.get()==0) ptr.reset(new myclass);
+ // ...
+ ptr->someFct();
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.obtain_the_pointer_to_the_thread_specific_object_of_another_thread"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.obtain_the_pointer_to_the_thread_specific_object_of_another_thread" title="Obtain
+ the pointer to the thread-specific object of another thread">Obtain
+ the pointer to the thread-specific object of another thread</a>
+</h6></div></div></div>
+
+ Besides, other threads can get access to the data provided a thread::id
+ by:
+ 
+<pre class="programlisting">boost::thread th=bith::make_decorated_thread(func);
+
+ptr[th->get_id()]->foo();
+</pre>
+
+ where <code class="computeroutput">foo()</code>
+ is a function of <code class="computeroutput">myclass</code>.
+ 
+
+ This could work or not. The issue appears as we can get a reference
+ to a thread before the thread has started, so the setting of the thread
+ specific context could be not yet done. One way to manage with this
+ error is to get the shared pointer and check if it contains something
+ or not.
+ 
+<pre class="programlisting">shared_ptr<myclass> shp = ptr[th->get_id()]->foo();
+if (shp.get() != 0) shp->foo();
+else ...
+</pre>
+
+ When we need this we can pool:
+ 
+<pre class="programlisting">shared_ptr<myclass> shp;
+do {
+ shp = ptr[th->get_id()]->foo();
+} while(shp.get() == 0);
+shp->foo();
+</pre>
+
+ The library provides a synchonization mechanism to solve this issue.
+ The wait_and_get() function allows a thread to synchronize with the
+ setting from another thread.
+ 
+<pre class="programlisting">shared_ptr<myclass> shp = ptr.wait_and_get(th->get_id());
+shp->foo();
+</pre>
+
+ shared_ptr<myclass> shp = ptr.wait_and_get(th->get_id());
+ shp->foo(); or
+ 
+<pre class="programlisting">ptr.wait_and_get(th->get_id()->foo();
+</pre>
+
+ In order to ensure that the decorations have been called, a cleaner
+ and safer option is not to return the thread until it has been started.
+ This behavior is obtained each time the thread is created with an
+ <code class="computeroutput">AsynchronousExecutor</code>
+ decorator, as
+ 
+<pre class="programlisting">bith::basic_threader_decorator ae;
+BOOST_AUTO(th, bith::fork(ae, func));
+// here you are sure all the decorations have been called
+// so we can access any thread_specific_shared_ptr of the created thread.
+</pre>
+
+ The lifetime of the myclass instance is managed by a shared_ptr. One
+ reference is held by the thread (by means of a tss), a second is held
+ by the thread::id to shared_ptr<T> map and additional references
+ might be held by other threads, obtained by <code class="computeroutput">*pmyclass[th]</code>.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.iterating_through_all_the_thread_specific_context"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.iterating_through_all_the_thread_specific_context" title="Iterating
+ through all the thread specific context">Iterating
+ through all the thread specific context</a>
+</h6></div></div></div>
+
+ Another use case appears when some global controller needs to access
+ the thread specific data of all the threads. Several approaches are
+ here possible; the library has choosen to provide a map getter using
+ a external locking mechanism that 'ensure' that the map access is locked
+ during the map query.
+ 
+<pre class="programlisting">{
+ bith::thread_specific_shared_ptr<myclass>::lock_type lock(ptr.get_mutex());
+ const bith::thread_specific_shared_ptr<myclass>::map_type amap = ptr.get_map(lock);
+ // use the map
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.deleting_the_context"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.deleting_the_context" title="Deleting
+ the context">Deleting
+ the context</a>
+</h6></div></div></div>
+
+ When a thread exits, the objects associated with each <code class="computeroutput">boost::thread_specific_shared_ptr<></code>
+ instance is not inmediately destroyed due to its shared nature. It
+ is detached from the current thread and removed from the map. Only
+ when there are no more references to the shared pointer it will be
+ destroyed. By default, the object pointed to by a pointer <code class="computeroutput">p</code> is destroyed by invoking <code class="computeroutput">delete p</code>,
+ but this can be overridden for a specific instance of <code class="computeroutput">boost::thread_specific_shared_ptr<></code>
+ by providing a deleter routine to the constructor. In this case, the
+ object is destroyed by invoking <code class="computeroutput">deleter(p)</code> where <code class="computeroutput">deleter</code>
+ is the deleter routine supplied to the constructor. The deleter function
+ is called only when there are no more references to the shared pointer.
+ 
+<pre class="programlisting">// Add use of deleter !!!
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.cleanup_at_thread_exit"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_specific_shared_pointer.cleanup_at_thread_exit" title="Cleanup
+ at thread exit">Cleanup
+ at thread exit</a>
+</h6></div></div></div>
+
+ When a thread exits, the objects associated with each thread_specific_shared_ptr<>
+ instance is not inmediately destroyed due to its shared nature. Only
+ when there are no more references to the shared pointer it will be
+ destroyed. By default, the object pointed to by a pointer p is destroyed
+ by invoking delete p, but this can be overridden for a specific instance
+ of boost::thread_specific_shared_ptr<> by providing a cleanup
+ routine to the constructor. In this case, the object is destroyed by
+ invoking func(p) where func is the cleanup routine supplied to the
+ constructor. The cleanup functions are called in an unspecified order.
+ If a cleanup routine sets the value of associated with an instance
+ of boost::thread_specific_shared_ptr<> that has already been
+ cleaned up, that value is added to the cleanup list. Cleanup finishes
+ when there are no outstanding instances of boost::thread_specific_shared_ptr<>
+ with values. If a cleanup routine sets the value associated with an
+ instance of <code class="computeroutput">boost::thread_specific_shared_ptr<></code>
+ that has already been cleaned up, that value is added to the cleanup
+ list. Cleanup finishes when there are no outstanding instances of
+ <code class="computeroutput">boost::thread_specific_shared_ptr<></code>
+ with values.
+ 
+<pre class="programlisting">// Add use of at thread_exit!!!
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive" title="Keep
+ alive">Keep
+ alive</a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt>Interface</dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_mechanism_initialization">Keep
+ alive mechanism initialization</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_threads">
+ Which threads can be controlled?</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_enabling">
+ Enabling the keep alive mechanism</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_disabling">
+ Disabling the keep alive mechanism</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_persistent">
+ Configuring the dead persistency</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.access_from_the_current_thread">Access
+ from the current thread</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.access_from__the_controller_thread">Access
+ from the controller thread</a></dt>
+</dl></div>
+
+ We will use the implementation of the keep alive mechanism as tutorial
+ for the thread decorators, thread specific shared pointers and the keep
+ alive mechanism itself.
+ 
+
+ We want to detect situations on which a thread is looping or blocked
+ on some component. The user needs to state when this mechanism is enabled
+ or disabled.
+ 
+
+ Since the only purpose is to find threads that don't work, the thread
+ needs to say if it is alive to a controller. The controler requests at
+ predefined intervals if the thread is dead, and in this case it will
+ call a user specific function which by default aborts the program.
+ 
+
+ A thread is considered dead if during a given period the number of checkins
+ is inferior to a given threshold. These two parameters are given when
+ the keep alive mechanislm is enabled. At the begining of a thread the
+ keep alive mechanism is disabled.
+ 
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.interface"></a>Interface
+</h6></div></div></div>
+
+ Next follows the keep alive interface.
+ 
+<pre class="programlisting">namespace boost {
+namespace interthreads {
+ namespace this_thread {
+ class enable_keep_alive {
+ public:
+ enable_keep_alive(std::size_t periods=2, std::size_t checkins=1);
+ ~enable_keep_alive();
+ };
+
+ class disable_keep_alive {
+ public:
+ disable_keep_alive();
+ ~disable_keep_alive();
+ };
+
+ void keep_alive_point();
+ bool keep_alive_enabled();
+
+ typedef void (*on_dead_thread_type)(thread::id, thread*);
+ void set_on_dead_thread(on_dead_thread_type fct, thread* th=0);
+
+ }
+ bool keep_alive_enabled(thread::id);
+ void set_on_dead_thread(thread::id, on_dead_thread_type fct, thread* th=0);
+}
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_mechanism_initialization"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_mechanism_initialization" title="Keep
+ alive mechanism initialization">Keep
+ alive mechanism initialization</a>
+</h6></div></div></div>
+
+ There is a single controller <code class="computeroutput">keep_alive_mgr</code>.
+ The controler needs to access some thread specific shared context
+ <code class="computeroutput">thread_keep_alive_ctx</code>
+ to be able to control a thread.
+ 
+<pre class="programlisting">namespace detail {
+ struct thread_keep_alive_ctx {
+ // ...
+ static void init();
+
+ typedef thread_specific_shared_ptr<thread_keep_alive_ctx> tssp;
+ static tssp instance_;
+ static thread_decoration initializer_;
+ thread_keep_alive_internal* data_;
+ };
+ struct keep_alive_mgr {
+ // ...
+ static void initialize() {
+ boost::call_once(flag, init);
+ }
+ static void init() {
+ instance_=new keep_alive_mgr();
+ }
+ boost::thread thread_;
+ static boost::once_flag flag_;
+ static keep_alive_mgr* instance_;
+ };
+}
+</pre>
+
+ The initialization of the controller itself and the setting the thread
+ specific context is done using an internal thread decoration <code class="computeroutput">thread_keep_alive_ctx::initializer_</code> with <code class="computeroutput">thread_keep_alive_ctx::init</code>
+ as setup function.
+ 
+<pre class="programlisting">thread_specific_shared_ptr<detail::thread_keep_alive_ctx> thread_keep_alive_ctx::instance_;
+thread_decoration thread_keep_alive_ctx::initializer_(thread_keep_alive_ctx::init);
+boost::once_flag keep_alive_mgr::flag;
+</pre>
+
+ This setup function will initialize the <code class="computeroutput">keep_alive_mgr</code>
+ and then set the <code class="computeroutput">thread_specific_shared_ptr<></code> with a new <code class="computeroutput">thread_keep_alive_ctx</code>.
+ 
+<pre class="programlisting">void thread_keep_alive_ctx::init() {
+ keep_alive_mgr::initialize();
+ instance_.reset(new thread_keep_alive_ctx());
+}
+</pre>
+
+ The <code class="computeroutput">keep_alive_mgr::initialize</code>
+ function ensures just that the init function is called once using the
+ <code class="computeroutput">boost::call_once</code>. This <code class="computeroutput">init</code>
+ function creates the instance of the <code class="computeroutput">keep_alive_mgr</code>
+ singleton.
+ 
+<pre class="programlisting">void keep_alive_mgr::initialize() {
+ boost::call_once(flag_, init);
+}
+void keep_alive_mgr::init() {
+ instance_=new keep_alive_mgr();
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_threads"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_threads" title="
+ Which threads can be controlled?">
+ Which threads can be controlled?</a>
+</h6></div></div></div>
+
+ As the keep alive mechanism uses a thread decoration, the user needs
+ to explicitly call the <code class="computeroutput">bith::decorate</code>
+ function at the begining of the thread function or by wrapping the
+ thread function. Instead of having a specific function to call or use
+ a thread function wrapper, the keep alive uses the functions provided
+ by the thread decorator (<code class="computeroutput">bith::decorate</code>
+ and <code class="computeroutput">bith::thread_decorator</code>). So we must either
+ call <code class="computeroutput">bith::decorate</code> explicitly on the thread
+ function
+ 
+<pre class="programlisting">void fct() {
+ bith::decorate();
+ // ...
+}
+</pre>
+
+ or create the thread with the <code class="computeroutput">bith::make_decorator</code>
+ wrapper
+ 
+<pre class="programlisting">boost::thread th(bith::make_decorator(fct));
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_enabling"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_enabling" title="
+ Enabling the keep alive mechanism">
+ Enabling the keep alive mechanism</a>
+</h6></div></div></div>
+
+ To be controled by the keep alive manager we need to enable the mechanism
+ using the enable_keep_alive. By default this enabler requires the application
+ to do at least one check point every 2 seconds using the <code class="computeroutput">bith::keep_alive_point()</code>
+ function.
+ 
+<pre class="programlisting">void fct() {
+ using bith::this_thread;
+
+ // ...
+ enable_keep_alive ena;
+ // states that the thread will be declared dead if threre are
+ // less that 1 check_points in 2 seconds.
+ for(;;) {
+ // do a check point
+ keep_alive_point();
+ // ...
+ }
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_disabling"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_disabling" title="
+ Disabling the keep alive mechanism">
+ Disabling the keep alive mechanism</a>
+</h6></div></div></div>
+
+ Some times we need to do an external task that could take an undefined
+ time. We can then disable the keep alive mechanisme by using a disabler
+ <code class="computeroutput">bith::disable_keep_alive</code>.
+ 
+<pre class="programlisting">void fct() {
+ using bith::this_thread;
+
+ // ...
+ // states that the thread will be declared dead if threre are
+ // less that 1 check_points in 2 seconds.
+ enable_keep_alive enabler;
+ for(;;) {
+ // do a check point
+ keep_alive_point();
+
+ if (cnd) {
+ // when a blocking task spending an undefined time
+ // you can disable the keep alive mechanism
+ disable_keep_alive disabler;
+
+ }
+ }
+}
+</pre>
+
+ If on the contrary we don't want to disable the keep alive mechanism,
+ it should be interesting to do a <code class="computeroutput">boost::interruption_check_point()</code> just after the blocking task. In
+ this way if the task takes too much time and the thread is declared
+ dead, the possibility to manage the keep alive error by interrupting
+ the dead thread remains, once the task is finished.
+ 
+<pre class="programlisting">void fct() {
+ using boost::this_thread;
+ using bith::this_thread;
+
+ // ...
+ // states that the thread will be declared dead if threre are
+ // less that 1 check_points in 2 seconds.
+ enable_keep_alive enabler;
+ for(;;) {
+ // do a check point
+ keep_alive_point();
+
+ if (cnd) {
+ // when a blocking task spending an undefined time
+ // you can disable the keep alive mechanism
+ unknow_time_task();
+ interruption_check_point();
+
+ }
+ }
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_persistent"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.keep_alive_persistent" title="
+ Configuring the dead persistency">
+ Configuring the dead persistency</a>
+</h6></div></div></div>
+
+ The default enabling parameters could be too restrictive in some cases.
+ But the <code class="computeroutput">enable_keep_alive</code>
+ configures it with the two parameters. We can declare a thread dead
+ when the thread has not done a number of checkins in a given period.
+ This can be useful when one knows the time a given task should take.
+ 
+<pre class="programlisting">void fct() {
+ using bith::this_thread;
+
+ // ...
+ // states that the thread will be declared dead if threre are
+ // less that 4 check_points in 30 seconds.
+ enable_keep_alive enabler(15, 1);
+ for(;;) {
+
+ if (cnd) {
+ // it is know that this task will take no more than 15 seconds
+ enable_keep_alive control(15, 1);
+ know_time_task();
+ keep_alive_point();
+ this_thread::interruprion_check_point();
+ }
+
+
+ }
+ // ...
+}
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.access_from_the_current_thread"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.access_from_the_current_thread" title="Access
+ from the current thread">Access
+ from the current thread</a>
+</h6></div></div></div>
+
+ But how all this works. We start with enablers/disablers. Enablers/disablers
+ use RAII, so they can be nested and the context be restored on the
+ destructor. At the construction they store the current state of the
+ keep alive of this thread using the backup function and then they enable/disable
+ the KA mechanism. On destruction they restore the backed up context.
+ 
+<pre class="programlisting">enable_keep_alive::enable_keep_alive(
+ std::size_t periods, std::size_t checkins)
+{
+ backup_=detail::thread_keep_alive_ctx::instance()->backup(data_);
+ detail::thread_keep_alive_ctx::instance()->enable_keep_alive(periods, checkins);
+}
+
+enable_keep_alive::~enable_keep_alive() {
+ detail::thread_keep_alive_ctx::instance()->restore(backup_);
+}
+
+disable_keep_alive::disable_keep_alive() {
+ backup_=detail::thread_keep_alive_ctx::instance()->backup(data_);
+ detail::thread_keep_alive_ctx::instance()->disable_keep_alive();
+}
+
+disable_keep_alive::~disable_keep_alive() {
+ detail::thread_keep_alive_ctx::instance()->restore(backup_);
+}
+</pre>
+
+ These functions are quite simple
+ 
+<pre class="programlisting">thread_keep_alive_internal* thread_keep_alive_ctx::backup(thread_keep_alive_internal* new_data) {
+ thread_keep_alive_internal* the_backup=data_;
+ data_=new_data
+ return the_backup;
+}
+
+void thread_keep_alive_ctx::restore(thread_keep_alive_internal* backup) {
+ data_=backup;
+}
+
+void thread_keep_alive_ctx::enable_keep_alive() {
+ data_->enabled_=true;
+}
+void thread_keep_alive_ctx::disable_keep_alive() {
+ data_->enabled_ = false;
+}
+</pre>
+
+ Note that there is no need to check if the <code class="computeroutput">detail::thread_keep_alive_ctx::instance_</code>
+ contains a pointer because we have ensured that at initialization time.
+ 
+
+ Next there is the central function <code class="computeroutput">keep_alive_point()</code>. This function does nothing more
+ than relaying the request to the specific context of this thread. This
+ function just increases the number of <code class="computeroutput">checkins_</code>.
+ 
+<pre class="programlisting">void keep_alive_point() {
+ detail::thread_keep_alive_ctx::instance()->check_point();
+}
+
+void thread_keep_alive_ctx::check_point() {
+ ++data_->checkins_;
+}
+</pre>
+
+ The <code class="computeroutput">set_on_dead_thread()</code> does the same. This function just
+ stores the on-dead action.
+ 
+<pre class="programlisting">void set_on_dead_thread(on_dead_thread_type fct, thread* th) {
+ detail::thread_keep_alive_ctx::instance()->set_on_dead_thread(fct, th);
+}
+
+ void set_on_dead_thread(on_dead_thread_type fct, thread* th) {
+ data_->on_dead_=fct;
+ data_->thread_ptr_=th;
+ }
+</pre>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.access_from__the_controller_thread"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.keep_alive.access_from__the_controller_thread" title="Access
+ from the controller thread">Access
+ from the controller thread</a>
+</h6></div></div></div>
+
+ Up to now we have seen the use of <code class="computeroutput">bith::thread_keep_alive_ctx</code>
+ as a <code class="computeroutput">boost::thread_specific_ptr</code>, i.e. it is used
+ from the current thread.
+ 
+
+ We will see now how the controler behaves. The single instance of the
+ keep_alive_mgr has been created on the init function.
+ 
+
+ The constructor just constructs a thread with the loop function.
+ 
+<pre class="programlisting">keep_alive_mgr() : end_(false), thread_(boost::bind(loop, boost::ref(end_))) {}
+</pre>
+
+ The loop function will iterate, every second, over all the thread_keep_alive_ctx
+ threads specific contexts asking them to control themselves. Note that
+ as the map can be modified when threads are created or finished, we
+ need to protect the iteration externally with a lock on the protecting
+ mutex.
+ 
+<pre class="programlisting">static void loop(bool& end) {
+ boost::xtime t;
+ boost::xtime_get(&t,1);
+ while(!end) {
+ t.sec += 1;
+ boost::thread::sleep(t);
+ lock_type lock(thread_keep_alive_ctx::instance().get_mutex());
+ const detail::thread_keep_alive_ctx::tssp::map_type& tmap(
+ thread_keep_alive_ctx::instance().get_map());
+ thread_keep_alive_ctx::tssp::map_type::const_iterator it = tmap.begin();
+ for (;it != tmap.end(); ++it) {
+ it->second.control(it->first);
+ }
+ }
+}
+</pre>
+
+ The thread loops until the end variable is true. In order to stop proprely
+ this thread we will use the destructor of singleton instance. This
+ end variable is a reference to a variable stored on the keep_alive_mgr
+ context which has been initialized staticly. So its destrcutor will
+ be called when the program finishes. So it is up to the destructor
+ to set this variable and wait for the thread completion
+ 
+<pre class="programlisting">~keep_alive_mgr() {
+ end_=true;
+ thread_.join();
+}
+</pre>
+
+ The thread_keep_alive_ctx::control function behaves as follows: if
+ it is enabled, it decreases the number of remaining periods and if
+ the thread is declared dead it executes the on dead action and resets
+ the check-ins and periods.
+ 
+<pre class="programlisting">void control(thread::id id) {
+ if (data_->enabled_) {
+ --data_->periods_;
+ if (dead()) {
+ on_dead(id);
+ data_->checkins_=0;
+ data_->periods_=data_->total_periods;
+ }
+ }
+}
+</pre>
+</div>
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h5 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple" title="Thread
+ Tuple">Thread
+ Tuple</a>
+</h5></div></div></div>
+<div class="toc"><dl>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple.thread_tuple_launching">
+ Launching thread tuple</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple.thread_tuple_exceptions">
+ Exceptions in thread functions</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple.thread_tuple_joining">
+ Joining and detaching</a></dt>
+<dt><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple.thread_tuple_interruption">
+ Interruption</a></dt>
+</dl></div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple.thread_tuple_launching"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple.thread_tuple_launching" title="
+ Launching thread tuple">
+ Launching thread tuple</a>
+</h6></div></div></div>
+
+ A new thread tuple is launched by passing a collection of objects of
+ some callable type, that can be invoked with no parameters. These objects
+ are then copied into internal storage, and invoked on the newly-created
+ threads of execution. If the objects must not (or cannot) be copied,
+ then <code class="computeroutput">boost::ref</code> can be used to pass in a reference
+ to the function object. In this case, the user of <code class="computeroutput">thread_tuple<></code> must ensure that the referred-to
+ object outlives the newly-created thread of execution.
+ 
+<pre class="programlisting">struct callable
+{
+ void operator()();
+};
+
+bith::thread_tuple<2> copies_are_safe()
+{
+ callable x;
+ callable y;
+ return bith::thread_tuple<2>(x, y);
+} // x and y are destroyed, but the newly-created threads have a copy, so this is OK
+
+bith::thread_tuple<2> oops()
+{
+ callable x;
+ callable y;
+ return bith::thread_tuple<2>(boost::ref(x), boost::ref(y));
+} // x and y are destroyed, but the newly-created threads still have a reference
+ // this leads to undefined behaviour
+</pre>
+
+ If you wish to construct an instance of <code class="computeroutput">thread_tuple<></code> with a function or callable
+ object that requires arguments to be supplied, this can NOT be done
+ by passing additional arguments as is the case for threads to the
+ <code class="computeroutput">thread_tuple<></code>
+ constructor, and you will need to use bind explicitly.
+ 
+<pre class="programlisting">void find_the_question(int the_answer);
+
+bith::thread_tuple<2> deep_thought_2(boost::bind(find_the_question,42), boost::bind(find_the_question,16));
+</pre>
+
+ The arguments are copied into the internals of
+ Boost.Bind structure: if a reference is required, use <code class="computeroutput">boost::ref</code>, just as for references to callable
+ functions.
+ 
+
+ The limit on the number of additional arguments that can be passed
+ are specified by the Boost.Bind.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple.thread_tuple_exceptions"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple.thread_tuple_exceptions" title="
+ Exceptions in thread functions">
+ Exceptions in thread functions</a>
+</h6></div></div></div>
+
+ If the function or callable object passed to the <code class="computeroutput">thread_tuple<></code> constructor propagates an exception
+ that is not of type <code class="computeroutput">boost::thread_interrupted</code>,
+ when invoked, <code class="computeroutput">std::terminate()</code>
+ is called.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple.thread_tuple_joining"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple.thread_tuple_joining" title="
+ Joining and detaching">
+ Joining and detaching</a>
+</h6></div></div></div>
+
+ When the <code class="computeroutput">thread_tuple<></code> object that represents a collection
+ of threads of execution is destroyed, the threads become detached.
+ Once threads are detached, they will continue executing until the invocation
+ of the functions or callable objects supplied on construction completes,
+ or the program is terminated. The threads of a <code class="computeroutput">thread_tuple<></code> can also be detached by explicitly
+ invoking the detach member function on the <code class="computeroutput">thread_tuple<></code> object. In this case, all the
+ threads of the <code class="computeroutput">thread_tuple<></code> object cease to represent the
+ now-detached thread, and instead represents 'Not-a-Thread.
+ 
+
+ In order to wait for a tuple of threads of execution to finish, the
+ <code class="computeroutput">join()</code>
+ or <code class="computeroutput">timed_join()</code>
+ member functions of the <code class="computeroutput">thread_tuple<></code> object must be used. <code class="computeroutput">join()</code>
+ will block the calling thread until the all the threads represented
+ by the <code class="computeroutput">thread_tuple<></code> object have completed. If the
+ threads of execution represented by the <code class="computeroutput">thread_tuple<></code> object have already completed,
+ or the <code class="computeroutput">thread_tuple<></code> objects represents Not-a-Thread,
+ then <code class="computeroutput">join()</code>
+ returns immediately. <code class="computeroutput">timed_join()</code> is similar, except that a call to
+ <code class="computeroutput">timed_join()</code>
+ will also return if the threads being waited for do not complete when
+ the specified time has elapsed.
+ 
+
+ There is also a possibility to wait until the first thread completes,
+ interrupting the rest of the threads.
+ 
+</div>
+<div class="section" lang="en">
+<div class="titlepage"><div><div><h6 class="title">
+<a name="toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple.thread_tuple_interruption"></a><a href="tutorial.html#toward_boost_interthreads.users_guide.tutorial.thread_extensions.thread_tuple.thread_tuple_interruption" title="
+ Interruption">
+ Interruption</a>
+</h6></div></div></div>
+
+ A tuple of running threads can be interrupted
+ by invoking the <code class="computeroutput">interrupt_all()</code> member function of the corresponding
+ <code class="computeroutput">thread_tuple<></code>
+ object. When the interrupted threads next execute one of the specified
+ interruption points (or if it is currently blocked
+ whilst executing one) with interruption enabled, then a <code class="computeroutput">boost::thread_interrupted</code> exception will
+ be thrown in the interrupted thread. If not caught, this will cause
+ the execution of the interrupted thread to terminate. As with any other
+ exception, the stack will be unwound, and destructors for objects of
+ automatic storage duration will be executed.
+ 
+
+ See the Boost.Threads
+ library on how to avoid a thread being interrupted.
+ 
+
+ At any point, the interruption state for the current thread can be
+ queried by calling <code class="computeroutput">interruption_enabled</code>.
+ 
+<a name="interruption_points"></a>
+ 
+
+ See the Boost.Threads
+ library for the Predefined Interruption Points.
+ 
+</div>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright © 2008 -2009 Vicente J. Botet Escriba
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ 
+</div></td>
+</tr></table>
+<hr>
+<div class="spirit-nav">
+<a accesskey="p" href="getting_started.html"><img src="../../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../users_guide.html"><img src="../../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="bibliography.html"><img src="../../../../../../doc/html/images/next.png" alt="Next"></a>
+</div>
+</body>
+</html>

Modified: sandbox/interthreads/libs/interthreads/doc/implementation.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/implementation.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/implementation.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -41,11 +41,11 @@
[This library maps thread IDs to thread specific pointers to avoid contention on a single map.]]

[[Default versus explicit specific context setting]
-[This library provides explicit setting. In future release will provide explicit/eager and implicit/lazy specific context setting.]]
+[This library provides explicit setting. In future release will provide explicit/eager and implicit/lazy specific context setting. Note that implicit setting will need a factory or a default constructible type.]]

-[[Ordered or unordered map] [The current implementation use an ordered map. Future version will allow the user to configure this.]]
+[[Ordered or unordered map] [While the thread::id type is ordered, there is no need to use it. The current implementation use an ordered map. Future version will allow the user to configure this.]]

-[[Intrusive or not maps] [As the thread specific pointer is stored on only one map the current implementation use the intrusive container.]]
+[[Intrusive or not maps] [As the thread specific pointer is stored on only one map the implementation could use an intrusive container. This will be provided in future releases]]

[[Shared versus exclusive locking] [Locating the right TS pointer requires the use of mutex to prevent race conditions. The library use a a shared_mutex
because most of the access to the map will be readings by other threads. The problem is that the native conditions can not be used directly with
@@ -60,8 +60,8 @@
[variablelist

[[Ensuring keep alive manager singleton is initialized and the thread specific shared storage is set before use]
-[The use of the thread preamble ensures that the preables are called before the user thread function is called.
-The keep_alive preable use the call_once to ensure that the keep_alive manager is correctly initialized.]]
+[The use of the thread decoration ensures that the decoration are called before the user thread function is called.
+The keep_alive decoration use the call_once to ensure that the keep_alive manager is correctly initialized.]]

[[backup/restore context] [The real thread specific data is stored directly on the stack of enablers/disablers avoiding heap memory.
On enablers/disablers construction they store a backup pointer to the nesting context. This allows a quick restore.
@@ -75,8 +75,8 @@

[variablelist
[[Joining the first finishing thread]
-[In order to synchronize the finish of all the threads we use a internal class which store the index of the first
-thread notifying that it is finished. As the user function has no ideaof this index we wrap the user thread functions.
+[In order to synchronize the end of all the threads the libarry use a internal class which stores the index of the first
+thread notifying that it is finished. As the user function has no idea of this index we need to wrap the user thread functions.
]]
]

Modified: sandbox/interthreads/libs/interthreads/doc/installation.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/installation.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/installation.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -75,29 +75,7 @@
]
]

-In addition it depends on the following libraries that are not yet accepted on Boost
-[variablelist
-[
- [[@http://www.boost.org/libs/futures [*Boost.Futures]]] [for futures]
-]
-[
- [[@http://www.boost.org/libs/tp [*Boost.ThreadPool]]] [Only when using the __AE_ boost::tp::pool and the __ACT__ boost::tp::task]
-]
-]
-
-And also could depend conditionaly on the following libraries that even not submited on Boost.
-[variablelist
-[
- [[@http://www.boost.org/libs/chrono [*Boost.Chrono]]] [for time and duration]
-]
-[
- [[@http://www.boost.org/libs/move [*Boost.Move]]] [to emulate the move semantic.]
-]
-[
- [[@https://svn.boost.org/trac/boost/wiki/LibrariesUnderConstruction#Boost.SmartPtr.UniquePtr [*Boost.SmartPtr.UniquePtr]]] [for unique_ptr, ...]
-]

-]

[/========================]
[heading Exceptions safety]

Modified: sandbox/interthreads/libs/interthreads/doc/interthreads.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/interthreads.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/interthreads.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -150,7 +150,7 @@

[def __apply__ `apply`]

-[warning InterThreads is not a part of the Boost libraries.]
+[warning Toward Boost.InterThreads is not a part of the Boost libraries.]

[include overview.qbk]

Modified: sandbox/interthreads/libs/interthreads/doc/introduction.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/introduction.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/introduction.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -10,420 +10,6 @@
[section:motivation Motivation]
[/============================]

-[section Asynchronous Executors and Asynchronous Completion Token Handles]
-[/=======================================================================]
-
-In [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1883.pdf N1833 - Preliminary Threading Library Proposal for TR2]
-Kevlin Henney introduces the concept of `threader` an asynchronous executor and a function `thread()` that evaluates a function
-asynchronously and returns an asynchronous completion token `joiner`, able to join but also to get the value of the function result.
-
-In [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2185.html N2185 - Proposed Text for Parallel Task Execution]
-Peter Dimov introduces a `fork()` function able to evaluate a function asynchronously and returns a `future` handle.
-
-In [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2276.html N2276 - Thread Pools and Futures]
-Anthony William introduces `launch_in_thread` and `launch_in_pool` function templates which
-evaluates a function asynchronously either in a specific `thread` or a thread pool and
-returns a `unique_future` handle.
-
-In [@http://www.boostpro.com/vault/index.php?action=downloadfile&filename=boost-threadpool.3.tar.gz&directory=Concurrent%20Programming& Boost.ThreadPool]
-Oliver Kowalke proposes a complete implementation of a thread `pool` with a `submit()` function
-which evaluates a function asynchronously and returns a `task` handle.
-
-Behind all these proposals there is a concept of asynchronous executor, fork-like function and
-the asynchronous completion token handle.
-
-[table AE/ACT/fork-like relationship
- [
- [[*Proposal]] [[*executor]] [[*fork-like]] [[*ACT handle]]
- ]
- [
- [Boost.Thread] [`thread` class] [`thread()` constructor] [__thread__]
- ]
- [
- [Boost.ThreadPool] [__tp_pool__] [`submit()`] [__tp_task__]
- ]
- [
- [N2276] [__thread__] [`launch_in_thread()`] [`unique_future<T>`]
- ]
- [
- [N2276] [thread_pool] [`launch_in_pool()`] [`unique_future<T>`]
- ]
- [
- [N2185] [thread pool] [`fork()`] [`future<T>`]
- ]
- [
- [N1833] [`threader`] [`thread()`] [`joiner<T>`]
- ]
-]
-
-The asynchronous completion token models can follow two interfaces, the thread interface and
-the future interface. Some asynchronous completion tokens handle allow to recover the result of the evaluation of
-the function, others allow to manage the underlying thread of execution.
-
-It seems natural to make a generic __fork__ function that will evaluate a function asynchronously
-with respect to the calling thread and returns an ACT handle. The following metafunction
-associates an ACT handle to an asynchronous executor.
-
- template <typename AE, typename T>
- struct asynchronous_completion_token {
- typedef typename AE::template handle<T>::type type;
- };
-
-The result of forking a nullary function by an asynchronous executor is given by the metafunction result_of::fork<AE,F>
-
- namespace result_of {
- template <typename AE,typename F>
- struct __c_fork__ {
- typedef typename boost::result_of<F()>::type result_type;
- typedef typename asynchronous_completion_token<AE, result_type>::type type;
- };
- }
-
-The default implementation of fork delegates on fork asynchronous executor function.
-
- template< typename AE, typename F >
- typename result_of::fork<AE, F>::type fork( AE& ae, F fn ) {
- return ae.fork(fn);
- }
-
-Forking n-ary functions rely on the nullary version and bind.
-
- template< typename AE, typename F, typename A1, ..., typename An >
- typename asynchronous_completion_token<AE,
- typename boost::result_of<F(A1,..., An)>::type >::type
- fork( AE& ae, F fn, A1 a1, ..., An an ) {
- return ae.fork( bind( fn, a1, ..., an ) );
- }
-
-We can define a basic_threader which just returns a new thread as follows:
-
- class basic_threader {
- public:
- template <typename T>
- struct handle {
- typedef boost::thread type;
- };
-
- template <typename F>
- boost::thread fork(F f) {
- thread th(f);
- return boost::move(th);
- }
- };
-
-The library includes also a launcher class that creates a thread and returns a unique_future when forking
-
- class launcher {
- public:
- template <typename T>
- struct handle {
- typedef unique_future<T> type;
- };
- template <typename F>
- unique_future<typename result_of<F()>::type>
- fork(F f) {
- typedef typename boost::result_of<F()>::type result_type;
- packaged_task<result_type> tsk(f);
- unique_future<result_type> res = tsk.get_future();
- thread th(boost::move(tsk));
- return res;
- }
- };
-
-and a shared_launcher class that creates a thread and returns a shared_future when forking.
-
-Given the sequential example:
-
- double f( double a, int n )
- {
- double r = 0.0;
-
- for( int i = 1; i <= n; ++i )
- {
- double x = 1.0 / i;
- r += std::pow( x, a );
- }
-
- return r;
- }
-
- int main()
- {
- double m1 = f( 1.0, 1000000 );
- double m2 = f( 1.0, 5000000 );
- double m3 = f( 2.2, 1000000 );
- double m4 = f( 2.2, 5000000 );
-
- std::cout << m2 - m1 + m3 - m4 << std::endl;
- }
-
-The library allows a programmer to switch to parallel execution as follows:
-
- int main()
- {
- launcher l;
- boost::unique_future<double> fm1 = bith::fork( l, f, 1.0, 1000000 );
- boost::unique_future<double> fm2 = bith::fork( l, f, 1.0, 5000000 );
- boost::unique_future<double> fm3 = bith::fork( l, f, 2.2, 1000000 );
- boost::unique_future<double> fm4 = bith::fork( l, f, 2.2, 5000000 );
-
- std::cout << fm2.get() - fm1.get() + fm3.get() - fm4.get() << std::endl;
- }
-
-
-The question now is how we can adapt the example to an existing asynchronous executor such as
-the Boost.ThreadPool library. We need to specialize the template class
-asynchronous_completion_token to state which is the __ACT__ associate to the __tp_pool__.
-
- namespace boost { namespace interthreads {
-
- template <typename Channel, typename T>
- struct asynchronous_completion_token<boost::tp::pool<Channel>,T> {
- typedef boost::tp::task<T> type;
- };
-
- }}
-
-and also to specialize the fork function as the default one requires a fork member function and __tp_pool__ provides a `submit()` member function`
-
- namespace boost { namespace interthreads {
-
- template< typename Channel, typename F >
- result_of::fork<boost::tp::pool<Channel>, F>::type
- fork<boost::tp::pool<Channel>,F>( boost::tp::pool<Channel>& ae, F fn ) {
- return ae.submit(fn);
- }
- }
- }
-
-Evidently these specializations must be done on the `boost::interthreads` namespace.
-
-As the preceding is ilegal in C++03 we need to use an auxiliary class to define the default behaviour of the fork function
-
- namespace partial_specialization_workaround {
- template< typename AE, typename F >
- struct fork {
- static typename result_of::fork<AE,F>::type apply(AE& ae, F fn ) {
- return ae.fork(fn);
- }
- };
- }
- template< typename AE, typename F >
- typename result_of::fork<AE,F>::type
- fork( AE& ae, F fn ) {
- return partial_specialization_workaround::fork<AE,F>::apply(ae,fn);
- }
-
-And specialize partially the partial_specialization_workaround::fork class
-
- namespace boost { namespace interthreads {
- namespace partial_specialization_workaround {
- template< typename Channel, typename F >
- struct fork<boost::tp::pool<Channel>,F> {
- static typename result_of::fork<boost::tp::pool<Channel>, F>::type
- apply( boost::tp::pool<Channel>& ae, F fn ) {
- return ae.submit(fn);
- }
- };
- }
- }}
-
-Note that only the __fork__ function needs to be specialized. The library provides the other overloadings.
-
-We can write the preceding main function in a more generic way
-
- template < typename AE>
- void do(AE& ae)
- {
- typedef bith::result_of::fork<AE, int(*)(double, int) >::type auto_type;
- auto_type fm1 = bith::fork(ae, f, 1.0, 1000000 );
- auto_type fm2 = bith::fork(ae, f, 1.0, 5000000 );
- auto_type fm3 = bith::fork(ae, f, 2.2, 1000000 );
- auto_type fm4 = bith::fork(ae, f, 2.2, 5000000 );
-
- std::cout << fm2.get() - fm1.get() + fm3.get() - fm4.get() << std::endl;
- }
-
- int main()
- {
- launcher ae;
- do(ae);
- }
-
-and we can switch from using the launcher or the tp::pool just by changing one line
-
- int main()
- {
- boost::tp::pool<> ae(boost::tp::poolsize(6))
- do(ae);
- }
-
-Instead of defining a type, the user can make use of BOOST_AUTO once the
-associated files included on the threadpool sub-directory.
-
- BOOST_AUTO(fm1, bith::fork(ae, f, 1.0, 1000000 ));
-
-
-The library allows also to fork several functions at one time
-
- result_of::fork_all<AE, int(*)(), int(*)(), int(*)()>::type handles = bith::fork_all(ae, f, g, h);
- std::cout << get<1>(res).get() - get<0>(res).get() + get<2>(res).get() << std::endl;
-
-
-The result of the fork_all operation is a fusion tuple of asynchronous completion token handles.
-The user can apply any fusion algorithm on this tuple as for example
-
- bool b = fusion::none(handles, fct::interruption_requested());
-
-The asynchronous completion token models follows two interfaces, the thread interface and the
-unique_/shared_future interface.
-
-To make common tasks easier the library provides some functors in the name space fct:
-for the thread interface as
-
-* fct::join
-* fct::join_until
-* fct::join_for
-* fct::detach
-* fct::interrupt
-* fct::interrupt_requested
-
-and for the future operations as
-
-* fct::get
-* fct::wait
-* fct::wait_until
-* fct::wait_for
-* fct::is_ready
-* fct::has_value
-* fct::has_exception
-
-Here is an example for get:
-
- namespace fct {
- struct get {
- template<typename ACT>
- typename ACT::result_type operator()(ACT& t) const {
- return t.get();
- }
- };
- }
-
-In addition the library provides some non member functions that are the result of applying
-these functors to the tuple using a fusion algorithm:
-
-* join_all
-* join_all_until
-* join_all_for
-* detach_all
-* interrupt_all
-* interrupt_requested_on_all
-
-* get_all
-* wait_all
-* wait_all_until
-* wait_all_for
-* are_all_ready
-* have_all_value
-* have_all_exception
-
-Next follows how get_all is defined.
-
- template <typename MovableTuple>
- typename result_of::get_all<Sequence>::type
- get_all(Sequence& t) {
- return fusion::transform(t, fct::get());
- }
-
-The library defines in a systematic way the result_of of a function as a metafunction
-having the same name as the function on the namespace result_of, as the Boost.Fusion library
-does.
-
- namespace result_of {
- template <typename Sequence>
- struct get_all {
- typedef typename fusion::result_of::transform<Sequence, fct::get>::type type
- };
- }
-
-So the user can do the following
-
- result_of::fork_all<AE, int(*)(), int(*)(), int(*)()>::type res = bith::fork_all(ae, f, g, h);
- result_of::get_all<result_of::fork_all<AE, int(*)(), int(*)(), int(*)()>::type>::type values
- = bith::get_all(handles);
-
-or using a typedef
-
- typedef result_of::fork_all<AE, int(*)(), int(*)(), int(*)()>::type auto_type;
- auto_type handles = bith::fork_all(ae, f, g, h);
- result_of::get_all<auto_type>::type values= bith::get_all(handles);
-
-Note that the notation can be shortened by using the C++0x auto keyword.
-
- auto res = bith::fork_all(ae, f, g, h);
- auto values = bith::get_all(handles);
-
-or using BOOST_AUTO
-
- BOOST_AUTO(res, bith::fork_all(ae, f, g, h));
- BOOST_AUTO(values, bith::get_all(handles));
-
-Last but not least the library provides also some sugaring functions like
-wait_for_all that forks and wait for the completion of all the functions.
-
- result_of::wait_for_all<AE, int(*)(), int(*)(), int(*)()>::type res = bith::wait_for_all(ae, f, g, h);
- std::cout << get<1>(res) - get<0>(res) + get<2>(res) << std::endl;
-
-and wait_for_any, which works only with functions that return the same type or are convertible to the same
-type, and return the index and the value of any of the completed functions.
-
- result_of::wait_for_any<AE, int(*)(), int(*)(), int(*)()>::type res = bith::wait_for_any(ae, f, g, h);
- std::cout << "function " << res.first << " finshed first with result=" << res.second << std::endl;
-
-The current implementation use the wait_for_any function so any AE must provide a way to get a
-unique|shared_future from its __ACT__.
-
-The library defines a functor allowing the user to specialize it
-
- template <typename AE>
- struct get_future {
- template <typename T>
- shared_future<T>& operator()(typename asynchronous_completion_token<AE,T>::type& act)
- { return act.get_future(); }
- };
-
-Future versions will use the set_once synchronization.
-
-Resuming a simple way to define a new AsynchronousExecutor is to define a class as
-
- struct AsynchronousExecutor {
- template <typename T>
- struct handle {
- typedef implementation-specific-type-modeling-a-ACT type;
- };
-
- template <typename F>
- typename handle<typename result_of<F()>::type>::type
- fork(F f);
- };
-
-
-
-
-[endsect]
-
-[section Threader/Joiner]
-[/=============================================================================]
-
-See the [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1883.pdf N1833 - Preliminary Threading Library Proposal for TR2]
-where Kevlin Henney introduces the concept of threader as an asynchronous executor and a function thread that evaluates a function
-asynchronously and returns an asynchronous completion token joiner, able to join but also to get the value of the function result.
-
-The main specificity is that here we make a difference between unique_joiner (move-only) and shared_joiner and as consequence unique_threader and shared_threader.
-
-
-[endsect]
-
[section Decorators]
[/=============================================================================]

Modified: sandbox/interthreads/libs/interthreads/doc/models.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/models.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/models.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -10,260 +10,4 @@
[section Concepts]
[/===============]

-[/=============================================]
-[section Asynchronous Completion Token Concepts]
-[/=============================================]
-
-[/==================]
-[section Concept `ACT` ]
-[/==================]
-
-An __ACT__ allows to to wait for the completion of an asynchronous executed operation.
-An __ACT__ should be __Movable__ or __CopyConstructible__.
-
-[variablelist Notation
- [[`act`] [An __ACT__]]
- [[`f`] [A __Nullary__ function with type F]]
- [[`abs_time`] [A __system_time__]]
- [[`rel_time`] [A __Duration__]]
- [[`b`] [A bool]]
-]
-
-[heading Expression requirements]
-A type models a __AE__ if, the following expressions are valid:
-
-[table
- [[Expression] [Return type] [Runtime Complexity]]
- [[`act.wait()`] [void] [Constant]]
- [[`b = act.wait_until(abs_time)`] [bool] [Constant]]
- [[`b = act.wait_for(rel_time)`] [bool] [Constant]]
-]
-
-[heading Meta Expressions]
-[table
- [[Expression] [Type] [Compile Time Complexity]]
- [[`__is_movable__<ACT>::type`] [MPL boolean] [Constant]]
- [[`__has_future_if__<ACT>::type`] [MPL boolean] [Constant]]
- [[`__has_thread_if__<ACT>::type`] [MPL boolean] [Constant]]
-]
-
-[heading Expression Semantics]
-[
-table
- [[Expression] [Semantics]]
- [[`act.wait()`] [Waits until the `act` completes]]
- [[`b = act.wait_until(abs_time)`] [Waits until the `act` completes until `abs_time` is not reached]]
- [[`b = act.wait_for(rel_time)`] [Waits until the `act` completes for a `rel_time` duration]]
-]
-
-[heading Models]
-
-* __unique_future__
-* __shared_future__
-* __unique_joiner__
-* __shared_joiner__
-* __tp_task__
-* __thread__
-
-[endsect]
-
-[/=============================]
-[section Concept `FutureBasedACT` ]
-[/=============================]
-
-An __FutureBasedACT__ is a __ACT__ that associates a value expected on the its completion.
-
-[variablelist Notation
- [[`act`] [An __ACT__]]
- [[`f`] [A __Nullary_ function with type F]]
- [[`abs_time`] [A __system_time__]]
- [[`rel_time`] [A __Duration__]]
- [[`b`] [A bool]]
- [[`v`] [T]]
-]
-
-[heading Expression requirements]
-A type models an __FutureBasedACT__ if, in adition to being an __ACT__,
-the following expressions are valid:
-
-[table
- [[Expression] [Return type] [Runtime Complexity]]
- [[`b = act.is_ready()`] [bool] [Constant]]
- [[`b = act.has_exception()`] [bool] [Constant]]
- [[`b = act.has_value()`] [bool] [Constant]]
-]
-
-[heading Expression Semantics]
-[table
- [[Expression] [Semantics]]
- [[`b = act.is_ready()`] [Is true only if the associated state holds a value or an exception ready for retrieval.]]
- [[`b = act.has_exception()`] [true only if the associated state contains an exception.]]
- [[`b = act.has_value()`] [true only if the associated state contains a value]]
- [[`v = act.get()`] [returns the stored value]]
-]
-
-[heading Models]
-
-* __unique_future__
-* __shared_future__
-* __unique_joiner__
-* __shared_joiner__
-* __tp_task__
-
-[endsect]
-
-[/=============================]
-[section Concept `ThreadBasedACT` ]
-[/=============================]
-
-An __FutureBasedACT__ is a __ACT__ that associates a value expected on the its completion.
-
-[variablelist Notation
- [[`act`] [An __ACT__]]
- [[`f`] [A __Nullary_ function with type F]]
- [[`abs_time`] [A __system_time__]]
- [[`rel_time`] [A __Duration__]]
- [[`b`] [A bool]]
- [[`id`] [A thread::id]]
-]
-
-[heading Expression requirements]
-A type models an __FutureBasedACT__ if, in adition to being an __ACT__,
-the following expressions are valid:
-
-[table
- [[Expression] [Return type] [Runtime Complexity]]
- [[`act.join()`] [void] [Constant]]
- [[`b = act.joinable()`] [bool] [Constant]]
- [[`b = act.join_until(abs_time)`] [bool] [Constant]]
- [[`b = act.join_for(rel_time)`] [bool] [Constant]]
- [[`act.detach()`] [void] [Constant]]
- [[`act.interrupt()`] [void] [Constant]]
- [[`b = act.interruption_requested()`] [bool] [Constant]]
- [[`id = act.get_id()`] [bool] [Constant]]
-]
-
-[heading Expression Semantics]
-[table
- [[Expression] [Semantics]]
- [[`act.join()`] [Constant]]
- [[`b = act.joinable()`] [Constant]]
- [[`b = act.join_until(abs_time)`] [Constant]]
- [[`b = act.join_for(rel_time)`] [Constant]]
- [[`act.detach()`] [Constant]]
- [[`act.interrupt()`] [Constant]]
- [[`b = act.interruption_requested()`] [Constant]]
- [[`is = act.get_id()`] [Constant]]
-]
-
-[heading Models]
-
-* __unique_joiner__
-* __shared_joiner__
-* __thread__
-* __tp_task__
-
-[endsect]
-
-[endsect]
-
-[/======================================]
-[section Asynchronous Executors Concepts]
-[/======================================]
-
-[/==========================================================================================]
-[section Concept `AsynchronousExecutor`]
-[/==========================================================================================]
-
-An __AsynchronousExecutor__ executes asynchronously a function and returns an __ACT__ when calling the fork function on it.
-
-[variablelist Notation
- [[`ae`] [An __AE__]]
- [[`f`] [A Nullary function with type F]]
- [[`act`] [An __ACT__]]
-]
-
-[heading Expression requirements]
-A type models a __AE__ if, the following expressions are valid:
-
-[table
- [[Expression] [Return type] [Runtime Complexity]]
- [[`__fork__(ae, f)`] [__ACT__] [Constant]]
- [[`get_future<AE>()(act)`] [__Future__] [Constant]]
- [[`__asynchronous_completion_token__<AE, T>::type`] [Model of __ACT__ satisfying `__act_value<ACT>::type` is `T`] [Constant]]
-]
-
-[heading Meta Expressions]
-[table
- [[Expression] [Model Of] [Compile Time Complexity]]
- [[`get_future<AE>::type`] [] [Amortized constant time]]
- [[`__result_of_advance_c__<I, N>::type`] [] [Linear]]
-]
-
-[heading Expression Semantics]
-[
-table
- [[Expression] [Semantics]]
- [[`act = __fork__(ae, f)`] [request `ae` to execute asynchronously the function `f`and returns an __ACT__ ]]
- [[`get_future<AE>()(act)`] [gets a reference to a __Future__]]
-]
-
-[heading Constraints]
-The following constraints applies:
-
-* `act_value<__ACT__>::type == boost::result_of<F()::type>`
-
-[heading Models]
-
-* __unique_threader__
-* __shared_threader__
-
-[endsect]
-
-
-[/==========================================================================================]
-[section Concept `IntrinsicAsynchronousExecutor`]
-[/==========================================================================================]
-
-
-The default fork implementation put some requirements in its __AE__ parameter. This concept is related to this.
-An __IAE__ is __AE__ that works well with the default implementation of __fork__.
-
-[variablelist Notation
- [[`ae`] [An __IAE__]]
- [[`f`] [A __Nullary__ function]]
-]
-
-[heading Expression requirements]
-A type models an __IAE__ if, in adition to being an __AE__,
-the following expressions are valid:
-
-[table
- [[Expression] [Return type] [Runtime Complexity]]
- [[`ae.fork(f)`] [`handle<boost::result_of<F()>::type`] [Constant]]
-]
-
-[heading Meta Expressions]
-[table
- [[Expression] [Model Of] [Compile Time Complexity]]
- [[`handle<boost::result_of<F()>::type`] [__ACT__] [Constant ]]
-]
-
-[heading Expression Semantics]
-[
-table
- [[Expression] [Semantics]]
- [[`ae.fork(f)`] [executes asynchronously the function `f`and returns a __handle__ ]]
-]
-
-
-[heading Models]
-* __unique_threader__
-* __shared_threader__
-
-
-[endsect]
-
-[endsect]
-
[endsect]

Modified: sandbox/interthreads/libs/interthreads/doc/overview.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/overview.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/overview.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -15,36 +15,18 @@

__boost_interthreads__ extends __boost_thread__ adding some features:

-* An asynchronous execution framework working with __AE__ and __ACT__. It includes some generic functions and several __AE__ and __ACT__:
- * fork and fork_all to execute asynchronously functions
- * fork_after: request an __AE__ to execute a function asynchronously once each one of __ACT__ in the dependency tuple parameter are ready. It is similar to the async_with_dependencies proposed Peter Dimov.
- * generic get, join, ... free functions to synchroyze on an __ACT__
- * generic get_all, join_all, ... free functions to synchroyze on multiple __ACT__
- * generic wait_for_all, wait_for_any to execute asynchronously functions and wait for the completion of all or any of them.
-
-* Some __AE__ and __ACT__ models
- * basic_threader: can be seen as a thread factory executing asynchronously a function on the returned thread.
- * launchers: Lanchers can be seen as a future factory executing asynchronously a function on a hiden thread.
- * threader/joiner: A Threader runs a unary function in its own thread. A Threader can be seen as a Joiner
- factory executing asynchronously a function on a thread encapsulated on the returned Joiner. The joiner is used
- to synchronise with and pick up the result from a function or to manage the encapsulated thread.
- * __tp_pool__ and __tp_task__ customization as an __AE__ and an __ACT__ respectively. __tp_pool__ can be seen as
- a __tp_task__ factory executing asynchronously a function on a pool of threads.
- * a generic asynchronous_executor_decorator which allows to decorate the function to be evaluated asynchronously.
-
-* Some thread extension
- * A thread_decoration class allowing to define setup/cleanup functions which will be called only once by thread (if
+* A thread_decoration class allowing to define setup/cleanup functions which will be called only once by thread (if
the thread function is decorated with thread_decorator): setup before the thread function and cleanup at thread exit.
It is used together with asynchronous_executor_decorator

- * A thread_decorator/thread_decorate class/function which decorate a thread function in order to call the setup and the
+* A thread_decorator/thread_decorate class/function which decorate a thread function in order to call the setup and the
cleanup of all the thread_decorations.

- * A thread specific shared pointer which is an extension of the thread_specific_ptr providing access
+* A thread specific shared pointer which is an extension of the thread_specific_ptr providing access
to this thread specific context from other threads.
As it is shared the stored pointer is a shared_ptr instead of a raw one.

- * A thread keep alive mechanism: this mechanism allows to detect threads that do not prove that they are alive by
+* A thread keep alive mechanism: this mechanism allows to detect threads that do not prove that they are alive by
calling to the keep_alive_point regularly.
When a thread is declared dead a user provided function is called, which by default will abort the program.

@@ -59,13 +41,9 @@

* thread_group_once: an extension of the boost::thread_group which allows to join the completion of any thread in the group using for that the set_once synchronizer.

+[note thread_decorator and thread_specific_shared_ptr are based on the original implementation of [@http://www.boost-consulting.com/vault/index.php?directory=Concurrent%20Programming [*threadalert]]
+written by Roland Schwarz.]

-References
-
-* thread_decorator and thread_specific_shared_ptr are based on the original implementation of [@http://www.boost-consulting.com/vault/index.php?directory=Concurrent%20Programming [*threadalert]]
-written by Roland Schwarz.
-
-* threader/joiner are based on the original idea of Kevlin Henney [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1883.pdf N1833 - Preliminary Threading Library Proposal for TR2]

[/====================================]

Modified: sandbox/interthreads/libs/interthreads/doc/rationale.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/rationale.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/rationale.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -49,9 +49,9 @@
```
]]

-[[Mimic shared_ptr] [From the point of the other threads thread_specific_shared_ptr behaves as a shared_ptr lockup.
+[[Mimic shared_ptr] [From the point of view of the other threads thread_specific_shared_ptr behaves as a shared_ptr lockup.
From the point of view of the current thread the stored pointer is located in a shared_pointer, so we can use the shared_ptr deleter feature
-From it we takes:
+From shared_ptr takes:

```T* get() const;
T* operator->() const;

Modified: sandbox/interthreads/libs/interthreads/doc/reference.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/reference.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/reference.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -20,82 +20,6 @@
[endsect]

-[section AE/ACT Framework Reference]
-
-[include reference/act_traits.qbk]
-
-[section AE operations]
-
-[include reference/fork.qbk]
-[include reference/fork_after.qbk]
-[include reference/fork_all.qbk]
-[include reference/wait_for_all.qbk]
-[include reference/wait_for_any.qbk]
-
-[endsect]
-
-[include reference/algorithm.qbk]
-
-[section Future based ACT operations]
-[include reference/wait.qbk]
-[include reference/wait_until.qbk]
-[include reference/get.qbk]
-[include reference/is_ready.qbk]
-[include reference/has_value.qbk]
-[include reference/has_exception.qbk]
-
-[include reference/wait_all.qbk]
-[include reference/wait_all_until.qbk]
-[include reference/get_all.qbk]
-[include reference/are_all_ready.qbk]
-[include reference/have_all_value.qbk]
-[include reference/have_all_exception.qbk]
-
-[endsect]
-
-[section Thread based ACT operations]
-
-[include reference/detach.qbk]
-[include reference/joinable.qbk]
-[include reference/join.qbk]
-[include reference/join_until.qbk]
-[include reference/interrupt.qbk]
-[include reference/interruption_requested.qbk]
-
-
-[include reference/detach_all.qbk]
-[include reference/join_all.qbk]
-[include reference/are_all_joinable.qbk]
-[include reference/join_all_until.qbk]
-[include reference/interrupt_all.qbk]
-[include reference/interruption_requested_all.qbk]
-[endsect]
-
-
-[endsect]
-
-[section AE/ACT Models Reference]
-
-[include reference/basic_threader.qbk]
-[include reference/launcher.qbk]
-[include reference/threader.qbk]
-[include reference/scheduler.qbk]
-
-[include reference/typeof/futures.qbk]
-[include reference/typeof/launcher.qbk]
-[include reference/typeof/threader.qbk]
-[include reference/typeof/basic_threader.qbk]
-[include reference/typeof/scheduler.qbk]
-
-[include reference/asynchronous_executor_decorator.qbk]
-[include reference/basic_threader_decorator.qbk]
-[include reference/threader_decorator.qbk]
-[include reference/launcher_decorator.qbk]
-
-[/include reference/asynchronous_adapter.qbk]
-
-[endsect]
-
[section Thread Array Reference]

[include reference/set_once.qbk]

Modified: sandbox/interthreads/libs/interthreads/doc/reference/thread_decorator.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/reference/thread_decorator.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/reference/thread_decorator.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -55,15 +55,15 @@
Objects of type `thread_decorator` are movable, so they can be stored in move-aware containers, and returned from functions.
This allows the details of thread decoration to be wrapped in a function.

-thread_decorator make_decorator();
+ thread_decorator make_decorator();

-void f()
-{
- boot::thread some_thread(make_decorator());
- some_thread.join();
-}
+ void f()
+ {
+ boot::thread some_thread(make_decorator());
+ some_thread.join();
+ }

-[note On compilers that support rvalue references, `thread_decorator` provides a proper move constructor and move-assignment operator,
+[note On compilers that support rvalue references, `thread_decorator` will provides a proper move constructor and move-assignment operator,
and therefore meets the C++0x `MoveConstructible` and `MoveAssignable` concepts. With such compilers, `thread_decorator` can therefore
be used with containers that support those concepts.

@@ -110,8 +110,12 @@

[[Thread safety:][safe]]

+[[Limitations:][The current implementation defines overloads up to four parameters.]]
+
]

+
+
[endsect]

[section:decorator_thread_decoration_decorate_copy_move_constructor Copy Move Constructor]
@@ -232,7 +236,7 @@

[[Throws:] [Any exception thrown by the decorations or the user function.]]

-[[Thread safety:][unsafe - depends on the decorations constructio/destruction.]]
+[[Thread safety:][unsafe - depends on the decorations construction/destruction.]]

]

@@ -257,7 +261,7 @@

[[Throws:] [Any exception thrown by the decorations.]]

-[[Thread safety:][unsafe - depends on the decorations constructio/destruction.]]
+[[Thread safety:][unsafe - depends on the decorations construction/destruction.]]

]

Modified: sandbox/interthreads/libs/interthreads/doc/reference/thread_keep_alive.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/reference/thread_keep_alive.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/reference/thread_keep_alive.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -8,6 +8,8 @@
[section:keep_alive_file_hpp Header `<boost/interthreads/thread_keep_alive.hpp>`]
[/==========================================================================================]

+Includes the keep alive enabling/disabling classes and non member functions.
+
 namespace boost {
 namespace interthreads {
 namespace this_thread {
@@ -25,6 +27,8 @@
[section:enable_keep_alive class `enable_keep_alive`]
[/==========================================================================================]

+Keep alive enabler.
+
 class enable_keep_alive : private noncopyable{
 public:
 enable_keep_alive(std::size_t threshold=2, std::size_t tap=1);
@@ -65,6 +69,8 @@
[section:keep_alive_disable_keep_alive class `disable_keep_alive`]
[/==========================================================================================]

+Keep alive disabler.
+
 class disable_keep_alive private noncopyable {
 public:
 disable_keep_alive();
@@ -105,6 +111,8 @@
[section:keep_alive_keep_alive_check_point Non Member Function `keep_alive_check_point()`]
[/==========================================================================================]

+Keep alive check point.
+
 void keep_alive_check_point();

[variablelist
@@ -120,6 +128,8 @@
[section:keep_alive_keep_alive_enabled Non Member Function `keep_alive_enabled()`]
[/==========================================================================================]

+Keep alive query.
+
 bool keep_alive_enabled();

[variablelist
@@ -134,6 +144,8 @@
[section:keep_alive_keep_alive_set_on_dead_thread Non Member Function `set_on_dead_thread()`]
[/==========================================================================================]

+Keep alive on dead thread action setting.
+
 void set_on_dead_thread(on_dead_thread_type fct);

[variablelist

Modified: sandbox/interthreads/libs/interthreads/doc/reference/thread_specific_shared_ptr.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/reference/thread_specific_shared_ptr.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/reference/thread_specific_shared_ptr.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -22,7 +22,7 @@
[/==========================================================================================]

`bith::thread_specific_shared_ptr<>` is an extension of the thread_specific_ptr providing access
-to this thread specific context from other threads.
+to the thread specific context from other threads.

template <typename T>
class thread_specific_shared_ptr : private noncopyable
@@ -121,7 +121,7 @@

[variablelist

-[[Effects:] [Remove from the map the current thread::id and destroys `*this`.]]
+[[Effects:] [Remove from the static map the current thread::id and destroys `*this`.]]

[[Throws:] [Nothing.]]

@@ -150,7 +150,7 @@

]

-[note The initial value associated with an instance of `boost::thread_specific_shared_ptr<>` is `NULL` for each thread.]
+[note The initial value associated with an instance of `boost::thread_specific_shared_ptr<>` is `0` for each thread.]

[endsect]

@@ -161,7 +161,7 @@

[variablelist

-[[Requires:] [`this->get()` is not `NULL`.]]
+[[Requires:] [`this->get()` is not `0`.]]

[[Returns:] [`this->get()`]]

@@ -180,7 +180,7 @@

[variablelist

-[[Requires:] [`this->get()` is not `NULL`.]]
+[[Requires:] [`this->get()` is not `0`.]]

[[Returns:] [`*(this->get())`]]

@@ -237,7 +237,6 @@
[[Effects:] [If `this->get()!=new_value` and `this->get()` is non-`NULL`, invoke `delete this->get()` or
`deleter(this->get())` as appropriate. Store `new_value` as the pointer associated with the current thread.]]

-[[Throws:] [`std::bad_alloc` when resources unavailable.]]

]

Modified: sandbox/interthreads/libs/interthreads/doc/tests.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/tests.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/tests.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -8,46 +8,8 @@
[section:tests Appendix E: Tests]

-[section AE/ACT]
+[section thread_specific_shared_pointer]
[table
- [[Name] [Description] [Pool] [BaTh][ShLa][ShTh][UnLa][UnLa] [Ticket]]
- [[do_test_member_fork] [Forks and get] [Pass] [????][Pass][Pass][????][????] [#]]
- [[do_test_member_fork_m] [Forks and get] [????] [Pass][Pass][????][????][????] [#]]
- [[do_test_member_fork_bind] [Forks and get] [Pass] [Pass][Pass][Pass][????][????] [#]]
- [[do_test_member_fork_bind_m] [Forks and get] [????] [????][Pass][????][????][????] [#]]
- [[do_test_fork] [Forks a nullary function and get] [Pass] [Pass][Pass][Pass][????][????] [#]]
- [[do_test_fork_1] [Forks a unary function and get] [Pass] [Pass][Pass][Pass][????][????] [#]]
- [[do_test_fork_1_m] [Forks a unary function and get] [????] [????][Pass][????][????][????] [#]]
- [[do_test_creation_through_functor] [Forks a functor] [Pass] [????][Pass][Pass][????][????] [#]]
- [[do_test_creation_through_reference_wrapper] [Forks a reference wrapper] [Pass] [????][Pass][Pass][????][????] [#]]
-
-
- [[do_test_wait] [Forks and waits] [Pass] [????][Pass][Pass][????][????] [#]]
- [[do_test_wait_until] [Forks and waits until a given time] [Pass] [????][Pass][Pass][????][????] [#]]
- [[do_test_wait_for] [Forks and waits for a given time] [Pass] [????][Pass][Pass][????][????] [#]]
- [[do_test_get] [Forks and get ] [????] [----][Pass][????][????][????] [#]]
- [[do_test_wait_all] [Forks several and waits all] [Pass] [----][Pass][Pass][????][????] [#]]
- [[do_test_wait_all_until] [Forks several and waits all until a given time] [????] [----][Pass][Pass][????][????] [#]]
- [[do_test_wait_all_for] [Forks several and waits all for a given time] [????] [----][????][????][????][????] [#]]
- [[do_test_set_all] [Forks several and get all using set_all] [Pass] [----][Pass][Pass][????][????] [#]]
- [[do_test_get_all] [Forks several and get all] [Pass] [----][Fail][Pass][????][????] [#]]
- [[do_test_wait_for_all] [wait for all] [Pass] [----][Pass][Pass][????][????] [#]]
- [[do_test_wait_for_any] [waits for any] [Fail] [----][Pass][Pass][????][????] [#]]
- [[do_test_wait_for_any_fusion_sequence] [Wait for any in a fusion sequence] [Fail] [????][????][Pass][????][????] [#]]
-
- [[do_test_member_fork_detach] [Forks and detach] [Fail] [????][----][Pass][????][????] [#]]
- [[do_test_thread_interrupts_at_interruption_point] [Interrupt] [Pass] [????][----][Pass][????][????] [#]]
- [[do_test_join] [Forks and join] [Pass] [Pass][Pass][Pass][????][????] [#]]
- [[do_test_join_until] [Forks and joins until a given time] [Pass] [Pass][Pass][Pass][????][????] [#]]
- [[do_test_join_for] [Forks and joins for a given time] [Pass] [Pass][Pass][Pass][????][????] [#]]
- [[do_test_join_all] [Forks several and join all] [Pass] [----][Pass][Pass][????][????] [#]]
- [[do_test_join_all_until] [Forks several and join all until a given time] [????] [----][????][????][????][????] [#]]
- [[do_test_join_all_for] [Forks several and join all for a given time] [????] [----][????][????][????][????] [#]]
-
- [[do_test_fork_after_join] [Fork after some dependent ACT and then join] [Pass] [????][Pass][Pass][????][????] [#]]
- [[do_test_fork_after_wait] [Fork after some dependent ACT and then wait] [Pass] [????][Pass][Pass][????][????] [#]]
- [[do_test_fork_after_get] [Fork after some dependent ACT and then get the value] [Pass] [????][Pass][Pass][????][????] [#]]
- [[XXXXXXXXXXXXXXXXXXXXXX] [XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX] [XXXX] [????][????][????][????][????] [#]]

]

Modified: sandbox/interthreads/libs/interthreads/doc/tickets.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/tickets.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/tickets.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -21,59 +21,7 @@
]
[
     [bug]
- [v0.2#1]
- [ae::get_all do not work yet]
- [get_all do not work because fusion transform sequence function can not take non const sequences.
-I have emulated it using set_all and a transformation for a tuple of ACT to a tuple of result_type.
-]
- [Closed]
- [do_test_get_all]
- [v0.4]
-]
-[
- [bug]
- [v0.2#2]
- [Some trouble with the use of tp::pool directly, use scheduler instead]
- [Four issues.
-* The parameter to fork on tp:pool was a const F& instead of a F.
-* Direct use of fork_all resolved for the other AE by ADL, which could not be the case fro the tp::pool.
-* fork specialization for tp::pool incorrent.
-* use of the default handle instead of asynchronous_completion_token traits class]
- [Closed]
- [See tp_pool test suite]
- [v0.3.1]
-]
-
-[
- [bug]
- [v0.3#1]
- [scheduler::do_test_wait_for_any do not work yet]
- [Not reproductible]
- [Closed]
- [scheduler::do_test_wait_for_any]
- [v0.3.1]
-]
-[
- [bug]
- [v0.3#2]
- [scheduler::do_test_fork_after_get do not work yet]
- [To solve this issue it enough to define boost::move for tp::task]
- [Closed]
- [scheduler::do_test_fork_after_get]
- [v0.3.1]
-]
-[
- [bug]
- [v0.3#3]
- [scheduler::do_test_fork_after_wait do not work yet]
- [To solve this issue it enough to define boost::move for tp::task]
- [Closed]
- [scheduler::do_test_fork_after_wait]
- [v0.3.1]
-]
-[
- [bug]
- [v0.3.1#1]
+ [v0.1.1#1]
     [keep alive mechanism crash when setting set_on_dead_thread before enabling the mechanism]
     [This was due to the fact that there were no default data for the backup.]
     [Closed]
@@ -82,7 +30,7 @@
]
[
     [bug]
- [v0.3.1#2]
+ [v0.1.1#2]
     [keep alive mechanism do not detect dead threads]
     [We need to reset the counters only when the period is 0.]
     [Closed]
@@ -91,7 +39,7 @@
]
[
     [bug]
- [v0.3.1#3]
+ [v0.1.1#3]
     [The set_on_dead_thread setting is not recovered by embeeding enablers/disablers]
     [The problem is that the on_dead and th thread pointer were stored on the backup. It is enough to store them on the ]
     [Closed]
@@ -100,7 +48,7 @@
]
[
     [bug]
- [v0.4.0#1]
+ [v0.2.0#1]
     [xxx]
     [xx]
     [Open]

Modified: sandbox/interthreads/libs/interthreads/doc/tutorial.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/tutorial.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/tutorial.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -688,9 +688,5 @@
[endsect]
[endsect]

-[section AE/ACT framework]
-[endsect]
-
-

[endsect]
\ No newline at end of file

Modified: sandbox/interthreads/libs/interthreads/doc/users_guide.qbk
==============================================================================
--- sandbox/interthreads/libs/interthreads/doc/users_guide.qbk (original)
+++ sandbox/interthreads/libs/interthreads/doc/users_guide.qbk 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -18,22 +18,8 @@
[section:bibliography References]
[/==============================]

-[/
-[variablelist
-[[boost::call_once] [Boost.Thread implementation for call_once.]]
-[[boost::this_thread::at_thread_exit] [Boost.Thread implementation for at thread exit cleanup registration.]]
-[[boost::thread_specific_ptr] [Boost.Thread implementation for TSS.]]
-[[boost::thread_group] [Boost.Thread thread_group.]]
-]
-]

[variablelist
-[[[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1883.pdf N1833 - Preliminary Threading Library Proposal for TR2]] []]
-[[[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2185.html N2185 - Proposed Text for Parallel Task Execution]] []]
-[[[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2276.html N2276 - Thread Pools and Futures]] []]
-[[[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2802.html N2802: A plea to reconsider detach-on-destruction for thread objects] ] []]
-[[[@http://www.boostpro.com/vault/index.php?action=downloadfile&filename=boost-threadpool.3.tar.gz&directory=Concurrent%20Programming& Boost.ThreadPool (O. Kowalke)]] []]
-[[[@http://www.justsoftwaresolutions.co.uk/threading/free-implementation-of-c++-futures.html Boost.Futures (A. Williams)]] []]
[[[@http://www.boost.org/libs/thread Boost.Thread (A. Williams)]] []]
]

@@ -48,8 +34,6 @@

[variablelist

-[[AE] [Asynchronous executor]]
-[[ACT] [Asynchronous completion token]]
[[alive (thread)] [a thread is considered alive when not dead.]]
[[cleanup decoration] [function called at thread exit.]]
[[dead (thread)] [a thread is considered dead when has not done enough keep alive check points for a given duration.]]
@@ -60,7 +44,6 @@
[[setup decoration] [function called before the thread starts.]]
[[TSS] [Thread Specific Storage.]]
[[TSSS] [Thread Specific Shared Storage.]]
-[[tuple (thread)] [group of threads statically determined and launched at construction time.]]
]

[endsect]

Modified: sandbox/interthreads/libs/interthreads/test/Jamfile.v2
==============================================================================
--- sandbox/interthreads/libs/interthreads/test/Jamfile.v2 (original)
+++ sandbox/interthreads/libs/interthreads/test/Jamfile.v2 2009-10-12 17:42:26 EDT (Mon, 12 Oct 2009)
@@ -21,15 +21,13 @@

project
 : requirements
-# <library>/boost/test//boost_unit_test_framework/<link>static
-# <library>/boost/thread//boost_thread/<link>static
- <library>/boost_1_39_0/libs/test/build//boost_unit_test_framework/<link>static
- <library>/boost_1_39_0/libs/thread/build//boost_thread/<link>static
+ <library>/boost/test//boost_unit_test_framework/<link>static
+ <library>/boost/thread//boost_thread/<link>static
 #<library>../build//boost_interthreads/<link>static
+ #<library>/sandbox/interthreads/libs/interthreads/build//boost_interthreads/<link>static

- <include>.
 <include>../../..
- <include>/boost_1_39_0
+ <include>$(BOOST_ROOT)
 <threading>multi
# <target-os>cygwin
# <interthreadapi>pthread
@@ -41,7 +39,8 @@
rule interthreads-run ( sources * )
{
 return
- [ run $(sources) ../build//boost_interthreads : : : <link>static ]
+ [ run $(sources) ../build//boost_interthreads/<link>static : : : ]
+ #[ run $(sources) : : : ]
# [ run $(sources) ../../../../libs/thread/build//boost_thread : : : : $(sources[1]:B)_lib ]
 ;
}

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk