[cpp-threads] "Agenda" for august 23-25 concurrency meeting

[Boehm, Hans]

Here is a quick attempt at a list of technical topics that I would hope
to cover at the meeting.  I would prefer to keep this very informal, and
attach only rough times to these, since I expect the list to change
before and during the meeting.

Very roughly, I would like to aim for:

Monday Morning: Atomics discussion.  (Herb - is 9:00 a good starting
time?)

Monday immediately after lunch: Brief overview of OpenMP status, if
there is a volunteer.

Rest of Monday afternoon, Tuesday morning: Memory model discussion,
starting with more detailed presentation.  Herb - Would you also like to
present? (We may want to start this Monday late morning, since some of
the atomics issues are not really separable from the memory model.)

Starting sometime Tuesday afternoon: Threads API discussion.

Wednesday afternoon, time permitting: library discussion.

My expectation is that we will close at around 4:00 on Wednesday, and
will probably start to lose people shortly before that.

Please let me or the list know if I omitted something you think is
important.

Technical issues:

Atomics
	Two levels of atomics (C-style + templates)?
	Bottom level operates on plain scalars, volatiles, or special
data?
		Does backward compatibility matter?
	double-word CAS?
	Does default atomic assignment include trailing fence?
		I.e. does it behave like Java volatiles?
		(Raised again by Herb's paper.)
	Other details?

Memory model
	Fairly detailed presentation (Hans and/or Clark)
	Construction of statics thread-safe by default?
		A tentative decision would be nice.
	Treatment of infinite loops.
	Do ordered atomics effectively order "raw" (unordered)
		atomic operations?
		(See
http://www.decadentplace.org.uk/pipermail/cpp-threads/2006-August/000989
.html) 
	Other issues?

Threads API
	Approach?
		I (Hans) think the alternatives are
			A) Boost + modifications
			B) More drastic redesign
			C) fallback: something minimal to let us talk
			about threads in the standard while using
			Boost/pthreads/win32/... in real programs
	Issues that are probably open either way:
		Constructor/destructor handling.
		Exception propagation past joins?
		Any cancellation support?
	Probably many other issues.

Library Issues
	Can we start a list?
	Can we leave basic_string as is?
	Do I/O operations introduce synchronizes-with relationships?
	Which I/O operations are atomic?
	Who is willing to look at these issues?
	Probably many other issues.

Recommended prereading (Hans' biased priority ordering):
	Draft of the Nelson & Boehm memory model/sequencing paper which
we hope
	to get out by Friday or so.  If you can't wait until then, the
current
	strawman memory model proposal.
	Herb's Prism paper.
(http://www.decadentplace.org.uk/pipermail/cpp-threads/2006-August/00100
9.html)
	N2047 atomics proposal.
	Pete Becker's thread library proposal (N1907).  (There are
competing proposals
      from at least Lawrence and Kevlin as well, but they are less
concrete, and
	probably less important to scrutinize in detail at this stage.)
	Except for Herb's paper, these are/will be all referenced from
	http://www.hpl.hp.com/personal/Hans_Boehm/c++mm/.
	Lawrence's summary of the other threads API discussion at the
Berlin
	C++ meeting (Ugly version at
	
http://www.decadentplace.org.uk/pipermail/cpp-threads/2006-April/000928.
html.
	Extract to html file.)
	Anything else that's referenced from the c++mm page and you find
	interesting.