Mandelbrot (Threaded)

[justsomeguy]

As I mentioned in my other threading post, I was going to attempt to Mandelbrot set in QB64 threaded. 

Before anyone says that Mandelbrot doesn't need to be threaded and one thread is fast enough, you are correct. This is my journey learning about threads and how to actually use them. I wanted share some of what I learned and document some of it. So, if any of you other brave souls attempt this, you have a place to start. That is all for the TED talk.

I used a modified version of qbguy's implementation of Mandelbrot for my basis. That can be found in QB64-PE samples that Steve posted some time ago.https://qb64phoenix.com/forum/showthread...pe+samples

It needs two files to work. First is a header file named "mandelThread.h" The second is the actual basic program. You can name it "Mandelthread.bas" or whatever you like.

I've tried this on Linux, MacOS, and Windows. Windows needs a special consideration.  Under Options --> Compiler Settings... --> C++ Compiler
Flags --> -pthread  and under C++ Linker Flags --> --static.



There are a few things to tinker with.

Code: (Select All)

'Are outside functions in worker thread allowed?
$LET THREADFUNC = TRUE
'Can the outside function have local variables?
$LET THREADFUNCLOCALVAR = TRUE
' Number of threads (1-32)
CONST cTHREADCOUNT = 32
' These affect actual calculation
CONST cREAL# = -2.0
CONST cIMAG# = -2.0
CONST cINCR# = 0.005

The header file. 

Code: (Select All)

// mandelThread.h
// Threading Header
#include "pthread.h"
// needed the sleep()
#include <unistd.h>
// needed for clock()
#include <time.h>

#define MAXTHREADS 32
#define RETRYCOUNT 5
// Initialize Threads
static pthread_t thread[MAXTHREADS];

// Setup Mutexes
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// thread arguments
typedef struct thread_data {
   int id;
} thread_data;

// Easy was to determine if a thread is running
static bool threadRunning[MAXTHREADS] = {false};

// QB's names for the threaded Subs
// You can locate these in your ''qb64pe/internal/temp'' folder.
// I found these in the 'main.txt'
void SUB_WORKER(int32*_SUB_WORKER_LONG_ID);

// wrap the subs so that you can easily get the void* for pthread
void* RunWorker(void *arg){
    thread_data *tdata=(thread_data *)arg;
    int id = tdata->id;
    threadRunning[id] = true;
    SUB_WORKER((int32*)&id);
}

// These are the commands that are accessed by you program
int invokeWorker(int id){
    // setup arguments to be sent to the thread
    thread_data tdata;
    tdata.id = id;
    // Threads are not always successfully started
    // So, we retry until it sticks or we exceed the retry count.
    int retry_count = 0;
    // Is it already running?
    if (!threadRunning[id]) {
        // try to start thread
        while(pthread_create( &thread[id], NULL, RunWorker, (void *)&tdata))
        {
            // thread is not running
            if (retry_count++ > RETRYCOUNT){
                // jumpout if tried more than RETRYCOUNT
                return threadRunning[id];
            }
            // wait a sec before trying again
            sleep(1);
        };
        // Give thread a sec to spool up
        int timeout_time = clock() * 1000 / CLOCKS_PER_SEC + 1000;
        do {} while (clock() * 1000 / CLOCKS_PER_SEC <= timeout_time && threadRunning[id] != true);
    }
    return threadRunning[id];
}


void joinThread(int id){
    pthread_join(thread[id],NULL);
    threadRunning[id] = false;
}

void exitThread(){
    pthread_exit(NULL);
}

void lockThread(){
    pthread_mutex_lock(&mutex);
}

void tryLockThread(){
    while (pthread_mutex_trylock(&mutex) != 0) {};
}

void unlockThread(){
    pthread_mutex_unlock(&mutex);
}

void lockDestroy(){
    pthread_mutex_destroy(&mutex);
}

The QB file.

Code: (Select All)

' Header interface

$CHECKING:OFF

DECLARE LIBRARY "./mandelThread"

  FUNCTION invokeWorker (BYVAL id AS LONG) ' start worker thread

  SUB joinThread (BYVAL id AS LONG) ' wait til thread is finished

  SUB exitThread ' must be called as thread exits

  SUB lockThread ' mutex lock

  SUB unlockThread ' mutex unlock

  SUB tryLockThread ' keep trying to lock thread

  SUB lockDestroy

END DECLARE

'Are outside functions in worker thread allowed?

$LET THREADFUNC = TRUE

'Can the outside function have local variables?

$LET THREADFUNCLOCALVAR = TRUE



_TITLE "Threaded Mandelbrot"

SCREEN _NEWIMAGE(800, 800, 32)

' Number of threads (1-32)

CONST cTHREADCOUNT = 32



' These affect actual calculation

CONST cREAL# = -2.0

CONST cIMAG# = -2.0

CONST cINCR# = 0.005



TYPE tWORKER

  xStart AS LONG

  yStart AS LONG

  xSize AS LONG

  ySize AS LONG

  xEnd AS LONG

  yEnd AS LONG

  x AS LONG

  y AS LONG

  r AS DOUBLE

  xt AS DOUBLE

  yt AS DOUBLE

  xx AS DOUBLE

  yy AS DOUBLE

  real AS DOUBLE

  imag AS DOUBLE

  incr AS DOUBLE

  colour AS DOUBLE

  sc AS LONG

  img AS _MEM

  offset AS _OFFSET

  command AS _BYTE

END TYPE



'Initialize resources

DIM SHARED AS tWORKER mWorker(cTHREADCOUNT)

DIM SHARED AS LONG argId

DIM AS LONG indx

DIM ky AS STRING



'Setup workers initial values

FOR indx = 0 TO cTHREADCOUNT - 1

  initWorker indx

NEXT



'Start the workers

FOR indx = 0 TO cTHREADCOUNT - 1

  IF invokeWorker(indx) = 0 THEN PRINT "Failed to start worker thread!": END

NEXT



' Main loop

DO

  ' handle user input

  ky = INKEY$

  IF ky = CHR$(27) THEN

    FOR indx = 0 TO cTHREADCOUNT - 1

      'set the workers command to quit

      mWorker(indx).command = -1

      ' wait for the thread to quit

      joinThread id

    NEXT

    ' cleanup the lock

    lockDestroy

    SYSTEM

  END IF

  ' display workers work

  FOR indx = 0 TO cTHREADCOUNT - 1

    ' lock the images so that they can be displayed

    ' in the case of an image it may not be strictly necessary, but

    ' data that needs to be correct it does.

    lockThread

    _PUTIMAGE (mWorker(indx).xStart, mWorker(indx).yStart), mWorker(indx).sc

    unlockThread

  NEXT

  ' keeping the framerate slow so that workers have more access to the image.

  _LIMIT 5

  _DISPLAY

LOOP

SYSTEM



'Work is split amongst the threads in horizontal bands.

SUB initWorker (id AS LONG)

  mWorker(id).xSize = _WIDTH

  mWorker(id).ySize = _HEIGHT / cTHREADCOUNT

  mWorker(id).xStart = 0

  mWorker(id).yStart = id * mWorker(id).ySize

  mWorker(id).xEnd = mWorker(id).xStart + mWorker(id).xSize

  mWorker(id).yEnd = mWorker(id).yStart + mWorker(id).ySize

  mWorker(id).incr = cINCR

  mWorker(id).real = cREAL

  mWorker(id).imag = cIMAG + mWorker(id).yStart * mWorker(id).incr



  mWorker(id).sc = _NEWIMAGE(mWorker(id).xEnd, mWorker(id).yEnd, 32)

  mWorker(id).img = _MEMIMAGE(mWorker(id).sc)

END SUB



'###################################################################################################

' Threaded Subs

'###################################################################################################

SUB worker (id AS LONG)

  ' Worker will continue to loop until mWorker(id).command is true

  DO

    mWorker(id).y = 0: DO

      mWorker(id).r = mWorker(id).real

      mWorker(id).x = 0: DO

        ' Decide on how the thread is going to run

        ' THREADFUNC determines if the calculation of the Mandelbrot will use a function or not

        ' THREADFUNCLOCALVAR determines if the function uses local variables

        $IF THREADFUNC = TRUE THEN

          lockThread

          argId = id

          $IF THREADFUNCLOCALVAR = TRUE THEN

            mandelA

          $ELSE

              mandelT

          $END IF

          unlockThread

        $ELSE

            mWorker(id).xt = mWorker(id).r: mWorker(id).yt = mWorker(id).imag

            mWorker(id).colour = 256.0: Do

            mWorker(id).xx = mWorker(id).xt * mWorker(id).xt: mWorker(id).yy = mWorker(id).yt * mWorker(id).yt

            If mWorker(id).xx + mWorker(id).yy >= 4 Then Exit Do

            mWorker(id).yt = mWorker(id).xt * mWorker(id).yt * 2 + mWorker(id).imag

            mWorker(id).xt = mWorker(id).xx - mWorker(id).yy + mWorker(id).r

            mWorker(id).colour = mWorker(id).colour - 1: Loop While mWorker(id).colour > 1

        $END IF

        ' calculate offset based on the x and y cooridates

        mWorker(id).offset = mWorker(id).img.OFFSET + (mWorker(id).x * 4) + (mWorker(id).y * mWorker(id).xSize * 4)

        lockThread

        ' draw colors to the image

        _MEMPUT mWorker(id).img, mWorker(id).offset + 0, mWorker(id).colour AS _UNSIGNED _BYTE

        _MEMPUT mWorker(id).img, mWorker(id).offset + 1, mWorker(id).colour AS _UNSIGNED _BYTE

        _MEMPUT mWorker(id).img, mWorker(id).offset + 2, mWorker(id).colour AS _UNSIGNED _BYTE

        _MEMPUT mWorker(id).img, mWorker(id).offset + 3, 255 AS _UNSIGNED _BYTE

        unlockThread

        mWorker(id).r = mWorker(id).r + mWorker(id).incr

      mWorker(id).x = mWorker(id).x + 1: LOOP UNTIL mWorker(id).x >= mWorker(id).xEnd

      mWorker(id).imag = mWorker(id).imag + mWorker(id).incr

    mWorker(id).y = mWorker(id).y + 1: LOOP UNTIL mWorker(id).y >= mWorker(id).yEnd



    'reset worker back to its original position

    mWorker(id).real = cREAL

    mWorker(id).imag = cIMAG + mWorker(id).yStart * mWorker(id).incr



  LOOP UNTIL mWorker(id).command

  ' This allows the thread to be joined at the end

  exitThread

END SUB

'###################################################################################################

' Threaded helper subs

'###################################################################################################

' Mandelbrot with no local variables

SUB mandelT

  mWorker(argId).xt = mWorker(argId).r: mWorker(argId).yt = mWorker(argId).imag

  mWorker(argId).colour = 256.0: DO

    mWorker(argId).xx = mWorker(argId).xt * mWorker(argId).xt: mWorker(argId).yy = mWorker(argId).yt * mWorker(argId).yt

    IF mWorker(argId).xx + mWorker(argId).yy >= 4 THEN EXIT DO

    mWorker(argId).yt = mWorker(argId).xt * mWorker(argId).yt * 2 + mWorker(argId).imag

    mWorker(argId).xt = mWorker(argId).xx - mWorker(argId).yy + mWorker(argId).r

  mWorker(argId).colour = mWorker(argId).colour - 1: LOOP WHILE mWorker(argId).colour > 1

END SUB



' Mandelbrot with local variables

SUB mandelA

  DIM AS DOUBLE x, y, xx, yy, c

  x = mWorker(argId).r: y = mWorker(argId).imag

  FOR c = 256.0 TO 1 STEP -1

    xx = x * x: yy = y * y

    IF xx + yy >= 4 THEN EXIT FOR

    y = x * y * 2 + mWorker(argId).imag

    x = xx - yy + mWorker(argId).r

  NEXT

  mWorker(argId).colour = c

END SUB