Variable modified by different threads.

[Ali Çehreli]

On 12/1/24 6:23 PM, Andy Valencia wrote:
> On Monday, 2 December 2024 at 02:02:56 UTC, Ritina wrote:
>> How can I implement a program where I have a global integer variable 
>> g, and three threads: the first thread increments g by 1, the second 
>> thread increments g by 2, and the third thread increments g by 3? 
>> Additionally, while these threads are running, I should be able to 
>> access the value of g both inside and outside the threads.
> 
> Here's my own shared memory across multiple threads sample program,  It 
> does a fine job of thrashing that cache line!
> 
> ```
> import core.atomic : atomicFetchAdd;
> import std.concurrency : spawn;
> import core.time : msecs;
> import core.thread : Thread;
> import core.memory : GC;
> 
> const uint NSWEPT = 100_000_000;
> const uint NCPU = 4;
> 
> void
> doadd(shared uint *buf)
> {
>      for (uint count = 0; count < NSWEPT/NCPU; ++count) {
>          atomicFetchAdd(buf[0], 1);
>      }
> }
> 
> void
> main()
> {
>      shared uint *buf =
>          cast(shared uint *)GC.calloc(uint.sizeof * 1, GC.BlkAttr.NO_SCAN);
> 
>      for (uint x = 0; x < NCPU-1; ++x) {
>          spawn(&doadd, buf);
>      }
>      doadd(buf);
>      while (buf[0] != NSWEPT) {
>          Thread.sleep(1.msecs);
>      }
> }
> ```
> 

And here's mine which has interesting amount of differences:

import core.atomic;
import core.thread;
import std.concurrency;
import std.conv;
import std.stdio;

// This is the variable that will be incremented collectively.
shared int g;

// This is the variable that will signal the threads to stop.
shared bool stopRequested;

// This is the thread function.
void modify(int increment) {
     while (!stopRequested) {
         g.atomicOp!"+="(increment);
     }
}

void main() {
     // Spawn some threads.
     enum totalThreads = 3;

     foreach (i; 0 .. totalThreads) {
         const increment = (i + 1).to!int;
         spawnLinked(&modify, increment);
     }

     // Wait for a while to request them to stop.
     Thread.sleep(2.seconds);
     stopRequested = true;

     // Wait until all threads are stopped.
     size_t stopped = 0;
     while (stopped != totalThreads) {
         receive((LinkTerminated _) {
                 stopped++;
             });
     }

     // Print the final value of g.
     writefln!"%,s"(g);
}

I am not sure whether

   stopRequested = true

is correct even when there is a single writer of that variable. There 
are several other methods of communicating the request. I chose that one 
for this example.

Ali