Parallel thread safety (fun fun)

[Mineko]

On Saturday, 1 February 2014 at 19:26:03 UTC, TheFlyingFiddle 
wrote:
> On Friday, 31 January 2014 at 21:33:50 UTC, Mineko wrote:
>> So, I'm implementing some parallelism in my engine (maybe some 
>> concurrency where appropriate later), and I'm having some 
>> issues with thread safety, and synchronize ain't cutting it.
>>
>> What I figure is that if I can get the IO class working within 
>> a parallel thread then everything else should fall in place, 
>> so, I need some help making the IO class thread-safe. (I'm new 
>> to thread safety btw, like, yesterday new >_>)
>>
>> Relevent file here: 
>> https://github.com/MinekoRox/Breaker-Engine/blob/master/src/breaker/utility/io.d
>>
>> Feel free to drop any other suggestions on what to do with 
>> that class if you want, always appreciated. :)
>
> First of all you are using the synchronized statement 
> incorrecly.
>
> synchronized bool addTime; <-- This does absolutely nothing.
>
> I am supprised this code is allowed.
>
> You can only use synchronized on class methods 
> http://dlang.org/class.html#synchronized-functions or on an 
> abitrary
> block of code 
> http://dlang.org/statement.html#SynchronizedStatement
>
> If you want to synchronize access to data you will have to 
> either make them shared and use  synchronized/atomic operations 
> on them or synchronize the use yourself. This is a quite 
> complex and bugprone activity and if your just getting started 
> i would not reccomend it. There is a simpler / better way that 
> i will describe later.
>
> Secondly the only use of concurency that i see in the IO class 
> is the attempt to write to a file from multiple threads. In the 
> write() method. This is not a good idea. Firstly you will not 
> be able to write any faster to the file since it's IO bound in 
> any case. The only effect if any is that you will use more 
> resources and that the output will appear in the file in random 
> order. (Probably not what you want)
>
>
> I would reccomend using message passing instead of even 
> attempting to synchronize things. This is ALOT simpler and if 
> your goal is to offload IO to another thread it's the way to go 
> IMHO.
>
> Here is a very simple logging application that writes to a file 
> using std.concurrency through message passing. To make things 
> simple it can only log messages from the thread that started 
> it. This would probably be the main thread in a game.
>
> module main;
> import logger;
>
> void main()
> {
>     startLoggerThread("log.txt");
>
>     log("Hello");
>     log("World");
>
>     stopLoggerThread();
> }
>
> //logger.d
> module logger;
>
> import std.concurrency;
> import std.file;
>
> //This is a unique identifier for a thread.
> Tid loggerTid;
>
> //Starts the logger thread.
> //(This must be done before any logging can take place.)
> void startLoggerThread(string logFile)
> {
>     loggerTid = spawn(&loggerEntry, logFile);
> }
>
> //Stops the logger thread.
> void stopLoggerThread()
> {
>     send(loggerTid, Shutdown());
> }
>
> //Called by the thread that started the logger.
> void log(string msg)
> {
>     //Send the message to log to the logger thread
>     //identified by the loggerTid.
>     send(loggerTid, msg);
> }
>
> //A tag struct symbolising the message shutdown.
> struct Shutdown { }
>
> void loggerEntry(string logFile)
> {
>     bool running = true;
>     //Recevie logging requests until stopLoggerThread is called.
>     while(running)
>     {
>     	receive(
>     	   //We get a message here when log is called.
>     	   (string msg)
>     	   {
>                //Create file if it does not already exists
>     	       //otherwise append to it.
>     	       if(!exists(logFile))
>     	           write(logFile, msg ~ "\n");
>     	       else
>     		   append(logFile, msg ~ "\n");
>     	    },
>     	    //If we get this message we stop the logger thread.
>     	    (Shutdown _)
>     	    {
>                running = false;
>     	    });
>     }
> }
>
> The example works by first creating a logging thread. This 
> thread then listens to logging requests from the main thread. 
> And logs all messages it receives.
>
> I would reccomend reading the TDPL chapter on concurrency if 
> you want to learn more.
>
> //Hope this was all helpful

Yes it was, this was more or less what I was looking for, 
especially about the synchronization part, thank you.