quote:Original post by Magmai Kai Holmlor
The only way to stop the text garbling is to use synchronization. If the performance delay of doing the printf is too long, then you can synchronize access to a queue and place the text in there (just a mutex & memcpy then).

quote:Original post by Magmai Kai Holmlor
Unfortunately high-performance and portability are diametrically opposed goals. Acquiring and releasing a mutex isn''t too cheap either. On Win32 you can use a critical section which is faster and works correctly for this case.

quote:Original post by Magmai Kai Holmlor
A portable solution is to use sockets Send data from one thread to the other over a socket, then it''s guaranteed to be queued up and synchronized. It''s important that the message send is performed with one write call. Avoid using printf/sprintf (and other C library functions) and you can avoid some multi-threading issues (multi-thread versions of those sometimes take a global mutex).

You could write your own routines that are thread-safe and do not require any locking (I have one to convert a float to a string).

quote:Original post by Magmai Kai Holmlor
All of this is only necessary if the IO delay is too high to tolerate. The over-all performance will be lower using a queue''ing method, but it lets you off-load the IO handling to another thread.

If you use a windowing system, these sorts of things are necessary to maintain a good response from the system. You''d be doing all the hard work involved with a multi-threaded GUI, without the benefit of having one The IO delay of updating a windowing system is usually higher than outputting text to the console, so it become important to have a queue''ing system with that sort of setup.

Sometimes you don''t need/want a queue, you can just stuff data in a hole, and have the UI thread periodically update the screen. However, this easier solution won''t work for your case because you have mutliple threads generating streaming data. It doesn''t get any harder than that!

quote:Original post by BaShildy
I was using critical sections in many of my threads. Unfortuantely it was printf/cout that was not thread safe. A thread wouldn''t finish its timeslice until it was done calling printf, but the call is not guarenteed to complete when your done calling it. If my thread finished, and a new thread outputted as well, they would both be jarbled. So my outputing was thread safe, but the library was not.

quote:Original post by BaShildy
Original post by Magmai Kai Holmlor
The only way to stop the text garbling is to use synchronization. If the performance delay of doing the printf is too long, then you can synchronize access to a queue and place the text in there (just a mutex & memcpy then).

Can you give a short example of doing this?

  class CriticalSection	{	private:		//Critical Sections should not be copied.		CriticalSection(const CCriticalSection& refCritSec);		CriticalSection& operator=(const CCriticalSection& refCritSec);	public:		inline CriticalSection()  {InitializeCriticalSection(&this->cs);}		inline ~CriticalSection() {    DeleteCriticalSection(&this->cs);}		inline void Lock()         {     EnterCriticalSection(&this->cs);}		inline void Unlock()       {     LeaveCriticalSection(&this->cs);}		operator CRITICAL_SECTION&() {return(cs);}	protected:		CRITICAL_SECTION cs;	};		template<typename TSync = CriticalSection>		struct auto_sync			{			typedef typename TSync sync_type;			inline auto_sync(sync_type& Sync_) : sync(Sync_)				{				assert(&Sync_);				sync.Lock();				}			inline auto_sync(sync_type* pSync_) : sync(*pSync_)				{				assert(pSync_);				sync.Lock();				}			inline ~auto_sync()				{				sync.Unlock();				}			private:				sync_type& sync;			};struct console{std::queue<std::string> queue;CriticalSection lock;void write_text(const char* str);void print_text();};//call this in your threadsvoid console::write_text(const char* str){auto_sync gaurd(this->lock);queue.push_back(str);//this will copy str into a std::string} //auto_lock will automatically release the critical section here//periodically call this from your UI threadvoid console::print_text(){auto_sync gaurd(this->lock);while(!this->queue.empty())   {   //replace printf with GUI routines if you decide to use one   //e.g. TextOut (Win32 GDI)   printf("%s\n", queue.front().c_str());   queue.pop();   }}