C#•3y ago

How to efficiently use Threads and locks

I'm writing a short program that computes the mandelbrot set.
I have implemented threads, but ts my first time using them and i'm a little confused.

            Thread thread1 = new Thread(() => bitmapRenderer.UpdateBitmap(0,height/8));
            Thread thread2 = new Thread(() => bitmapRenderer.UpdateBitmap(height/8,2*height/8));
            Thread thread3 = new Thread(() => bitmapRenderer.UpdateBitmap(2*height/8,3*height/8));
            Thread thread4 = new Thread(() => bitmapRenderer.UpdateBitmap(3*height/8,4*height/8));
            Thread thread5 = new Thread(() => bitmapRenderer.UpdateBitmap(4*height/8,5*height/8));
            Thread thread6 = new Thread(() => bitmapRenderer.UpdateBitmap(5*height/8,6*height/8));
            Thread thread7 = new Thread(() => bitmapRenderer.UpdateBitmap(6*height/8,7*height/8));
            Thread thread8 = new Thread(() => bitmapRenderer.UpdateBitmap(7*height/8,height));

            thread1.Start();
            thread2.Start();
            thread3.Start();
            thread4.Start();
            thread5.Start();
            thread6.Start();
            thread7.Start();
            thread8.Start();
            thread1.Join();
              .
              .
            thread8.Join();

            Thread thread1 = new Thread(() => bitmapRenderer.UpdateBitmap(0,height/8));
            Thread thread2 = new Thread(() => bitmapRenderer.UpdateBitmap(height/8,2*height/8));
            Thread thread3 = new Thread(() => bitmapRenderer.UpdateBitmap(2*height/8,3*height/8));
            Thread thread4 = new Thread(() => bitmapRenderer.UpdateBitmap(3*height/8,4*height/8));
            Thread thread5 = new Thread(() => bitmapRenderer.UpdateBitmap(4*height/8,5*height/8));
            Thread thread6 = new Thread(() => bitmapRenderer.UpdateBitmap(5*height/8,6*height/8));
            Thread thread7 = new Thread(() => bitmapRenderer.UpdateBitmap(6*height/8,7*height/8));
            Thread thread8 = new Thread(() => bitmapRenderer.UpdateBitmap(7*height/8,height));

            thread1.Start();
            thread2.Start();
            thread3.Start();
            thread4.Start();
            thread5.Start();
            thread6.Start();
            thread7.Start();
            thread8.Start();
            thread1.Join();
              .
              .
            thread8.Join();

There probably is a better way to create, start and join threads, but i wasn't able to find anything better.
Its not clear to me how threads work overall. I have a 16 thread CPU and using 8 threads bumped the usage from 10% to 30%.
How can i find out what a good number of threads to use is?

  lock (bmp) 
        {
              bmp.SetPixel(j,i,iterToColor(iterCount_temp));
        }

  lock (bmp) 
        {
              bmp.SetPixel(j,i,iterToColor(iterCount_temp));
        }

I had to lock the bitmap so that the threads wouldn't try to write at the same time.
But i feel like this isn't the best practise as the threads will wait on one another fairly often.
I wanted to save the X Y Color values in some structure and write all at once after joining, but was not yet able to come up with anything.
Any ideas?

JBizzy•9/18/23, 2:34 AM

i would probably recommend using the task/async await model if you want to do something like that, rather than trying to manage raw threads yourself

JakenVeina•9/18/23, 3:07 AM

the first thing you need to understand about ANY of this is that you can only parallelize work that is parallelizable

JakenVeina•9/18/23, 3:08 AM

what is the work that you're trying to parallelize here?

JakenVeina•9/18/23, 3:09 AM

the bitmap computations you're doing, these can be done completely independently?

JJakenVeina the bitmap computations you're doing, these can be done completely independently...

UmbranocturnaOP•9/18/23, 7:25 AM

I can compute each pixels color independently. Just the writing was a problem.

UmbranocturnaOP•9/18/23, 8:27 AM

This speeds it up a little, i get 100% cpu usage for a short time, but the writing to the bitmap seems to be a massive bottleneck.
Memory usage jumped aswell.

UUmbranocturna I can compute each pixels color independently. Just the writing was a problem.

JBizzy•9/18/23, 2:44 PM

You might try PLINQ

JBizzy•9/18/23, 2:44 PM

Makes parallel computation very fast and easy, and automatically handles thread joining

JBizzy•9/18/23, 2:44 PM

Then you just take the output of that and shove it in teh bitmap

UmbranocturnaOP•9/18/23, 2:45 PM

oh maybe i should have closed it, i have already made some improvements over yesterday.
stored results as a matrix of short instead of color -> memory usage down from 15gb to 700mb
writing results in bulk instead of individual pixels -> runntime down from 90 seconds to 26

UmbranocturnaOP•9/18/23, 2:46 PM

But i will have a look at PlinQ, maybe thts interesting too

JBizzy•9/18/23, 2:46 PM

yeah. would keep you from needing to deal w/ all the manual thread manipulation

JBizzy•9/18/23, 2:46 PM

the setup you initially showed looks trivial to linqize

UmbranocturnaOP•9/18/23, 2:46 PM

ended up doing this

UmbranocturnaOP•9/18/23, 2:47 PM

(credit to Chat GPT)

UmbranocturnaOP•9/18/23, 2:47 PM

JBizzy•9/18/23, 2:49 PM

something kinda like that.

JBizzy•9/18/23, 2:49 PM

you'd need to decompose your calculation and render functions though

UmbranocturnaOP•9/18/23, 2:50 PM

ill consider it, probably going to rewrite it multiple times anyway.