Is cout << msg an atomic action?

[Alex Vinokur]

void foo (int n)
{
std::ostringstr eam oss;
oss << "ABCD: " << n << std::endl;
std::cout << oss.str() << std::flush;
}

That function has been invoked in multiprocessing mode.
Output was something like:
ABCA: B1
C
etc.

Is cout << msg an atomic action?


Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

[Chris Thomasson]

"Alex Vinokur" <al****@users.s ourceforge.netw rote in message
news:a8******** *************** ***********@1g2 000hsl.googlegr oups.com...

>

void foo (int n)
{
std::ostringstr eam oss;
oss << "ABCD: " << n << std::endl;
std::cout << oss.str() << std::flush;
}

That function has been invoked in multiprocessing mode.
Output was something like:
ABCA: B1
C
etc.

Is cout << msg an atomic action?

no:

http://groups.google.com/group/comp....37f881199c5133
(read all...)

[James Kanze]

On Feb 4, 6:17 am, Alex Vinokur <ale...@users.s ourceforge.netw rote:

void foo (int n)
{
std::ostringstr eam oss;
oss << "ABCD: " << n << std::endl;
std::cout << oss.str() << std::flush;

}

That function has been invoked in multiprocessing mode.

Output was something like:
ABCA: B1
C
etc.

Is cout << msg an atomic action?

It depends on the implementation, but I would not normally
expect to be able to write to the same stream from two different
threads without some external synchronization . Both reading
from and writing to an iostream modify the object itself.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Alex Vinokur]

On Feb 4, 11:42*am, James Kanze <james.ka...@gm ail.comwrote:

On Feb 4, 6:17 am,AlexVinokur< [e-mail] urceforge.netwr ote:

void foo (int n)
{
* std::ostringstr eam oss;
* oss << "ABCD: " << n << std::endl;
* std::cout << oss.str() << std::flush;

}
That function has been invoked in multiprocessing mode.
Output was something like:
ABCA: B1
C
etc.
Is cout << msg an atomic action?

It depends on the implementation, but I would not normally
expect to be able to write to the same stream from two different
threads without some external synchronization . *Both reading
from and writing to an iostream modify the object itself.

I realize that
cout << msg1 << msg2;
is not an atomic action.

But is
cout << msg1;
also not atomic one?

Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

[Chris Thomasson]

"Alex Vinokur" <al****@users.s ourceforge.netw rote in message

news:38******** *************** ***********@q39 g2000hsf.google groups.com...

On Feb 4, 11:42 am, James Kanze <james.ka...@gm ail.comwrote:

On Feb 4, 6:17 am,AlexVinokur< [e-mail] urceforge.netwr ote:

void foo (int n)
{
std::ostringstr eam oss;
oss << "ABCD: " << n << std::endl;
std::cout << oss.str() << std::flush;

}

That function has been invoked in multiprocessing mode.

Output was something like:
ABCA: B1
C
etc.
Is cout << msg an atomic action?

It depends on the implementation, but I would not normally
expect to be able to write to the same stream from two different
threads without some external synchronization . Both reading
from and writing to an iostream modify the object itself.

I realize that
cout << msg1 << msg2;
is not an atomic action.

But is
cout << msg1;
also not atomic one?

On a single-threaded application yes; otherwise, well, good luck.

[peter koch]

On 4 Feb., 06:17, Alex Vinokur <ale...@users.s ourceforge.netw rote:

void foo (int n)
{
* std::ostringstr eam oss;
* oss << "ABCD: " << n << std::endl;
* std::cout << oss.str() << std::flush;

}

That function has been invoked in multiprocessing mode.

Output was something like:
ABCA: B1
C
etc.

Is cout << msg an atomic action?

I would be most surprised if it was. In theory, an implementation
could make some of these operations atomic, but it would be quite a
stupid thing to do for the simple reason that the atomicity is at the
wrong level.
In case you have user provided operator << these will hardly be atomic
as they can't use the same syncronisation objects as std::cout.

/Peter

/Peter