C++Talk.NET

James Hopkin · Guest

In the early days of C++ exception safety, I remember articles
approaching the subject of exceptions something like this (obviously
much better written):

"Here's a function that I've written. Ah, but it's not exception safe.
You have to put a try-catch round here. But then this other bit of
code needs a try-catch. So you'll have to change this other bit as
well. This ought to hold up in most situations."

These days, since Dave Abrahams' efforts in the exception
specifications of STL, and Herb Sutter's Exceptional C++ series, we
can write exception-safe code which is actually more elegant than what
we would probably have written all that time ago.

The point I want to make is that discussions between experts on
threading seem to me reminiscent of those early exceptions articles.

Is it likely that writing thread-safe code will become as natural as
writing exception-safe code is now, or is it just 'too hard', and
there'll always be an element of ugliness to it?

James

Disclaimer: my actual experience of threading is almost limited to: if
you want things to run simultaneously, run two executables. I have
read about the subject a fair amount, and tried to follow discussions
here and elsewhere.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Pete Becker · Guest

James Hopkin wrote:

dayton · Guest

We're in the early days of C++ threading. Some compilers have added
extensions to declare thread local variables. Perhaps Java-like edge
locking will migrate its way into C++.

A consensus has yet to be reached about what a thread should look like
in C++. If a thread is an object, then would the non-static members of
that class be thread specific local variables?

Note that until the STL came along, C++ had no system objects. Even
activities such as the global new() and delete() appear like functions,
not as members of some global class. If you look at the Boost threads
library, even those smart people model thread instantiation as a
function call.

Much of the design decisions in C++ were made to maintain its C-like
power for systems implementation; so any fancier additions to the
language must be made with an eye towards low-low overhead. It appears
same threading related features may satisfy the criteria.

Some features I'd like to see added to C++ to support threading:

1. a new keyword, similar to 'volatile', that would declare all
modifications to a variable are interlocked or suitable for atomic
compare-and-swap operation. Perhaps instead of a storage modifier, a
new POD needs to be created. This new POD would be suitable for
semaphore and mutex operations.

2. a new modifier for classes similar to Java's "synchronized". This
would add a strictly intraprocess lock to an object, and modify every
non-const method in the class to acquire the lock on entry and release
it on exit. Note this may be implemented right now in the language with
a little discipline -- but everyone knows you'll miss a critical
function when you're adding locking. Related to "synchronized" may be a
declaration where you've specified your class as thread-safe and ypu've
taken responsibility for making it so. This particular feature adds
overhead so I'm not enthusiastic about it.

3. A modifier for class and functions that specifies methods and
functions must be re-entrant -- no statics or modifications of global
variables unless the global itself has been declared thread-safe or
synchronized.

4. Standardize the support for thread local variables.

5. Standardize the support for openMP.

6. Add threading to the STL. Implement a thread as an abstract class
that the programmer instantiates with their own thread method. This
will encapsulate all the issues of thread local variables and reaping of
status.

It is simply not true that threading can only be implemented at the
design level of an application. When you create a class, you can make
it thread-safe and each method re-entrant. In modern systems, whenever
you use a sleep function, or deal with most GUI application frameworks,
you're using threading.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Phlip · Guest

dayton wrote:

Francis Glassborow · Guest

In article <XLNjd.27399$Qv5.3172 (AT) newssvr33 (DOT) news.prodigy.com>, Phlip
<phlip_cpp (AT) yahoo (DOT) com> writes

Thomas Richter · Guest

Hi,

Branimir Maksimovic · Guest

"Phlip" <phlip_cpp (AT) yahoo (DOT) com> wrote