Mandelbrot (Threaded) - Printable Version

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);

}

' 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