iothread.c

Go to the documentation of this file.

#include <SDL.h>
#include <SDL_thread.h>
#include <assert.h>
#include "iothread.h"
#include "random.h"

static SDL_cond *notify;

static SDL_Thread *thread = NULL;

struct Operation_t {
    ioOperation op;
    void *data;
};

static struct Operation_t queue[IO_QUEUE_SIZE];

static int queueLen = 0;

static int queueNext = 0;

static SDL_mutex *queueMutex = NULL;

static int opFlags = 0;

#define FLAG_CANCEL  1

#define FLAG_TERM    2

static int ioThread(void *ignore) {
    SDL_mutex *waitMutex;
    struct Operation_t oper;
    int next = 1;
    int lastLen;
    // initalize the random number generator
    RandInit();
    // create new mutex semaphores
    if ((queueMutex = SDL_CreateMutex()) == NULL) {
        // create failed!
        return -1;
    }
    if ((waitMutex = SDL_CreateMutex()) == NULL) {
        // create failed!
        SDL_DestroyMutex(queueMutex);
        queueMutex = NULL;
        return -1;
    }
    // lock it
    if (SDL_mutexP(waitMutex) == -1) {
        // lock failed!
        ioThread_die:
        SDL_DestroyMutex(waitMutex);
        SDL_DestroyMutex(queueMutex);
        queueMutex = NULL;
        return -1;
    }
    // wait for stuff to do
    while (SDL_CondWait(notify, waitMutex) == 0) {
        ioThread_noWait:
        // lock the queue
        if (SDL_mutexP(queueMutex) == -1) {
            // failed to use a mutex, so this isn't going to work
            goto ioThread_die;
        }
        // check for nothing in the queue
        if (queueLen-- == 0) {
            // time to quit
            break;
        }
        // store the number of items queued for a later check
        lastLen = queueLen;
        // clear the cancel request flag
        opFlags = 0;
        // copy the queue entry
        oper = queue[next];
        // advance the next counter
        next = (next + 1) % IO_QUEUE_SIZE;
        // release the queue
        SDL_mutexV(queueMutex);
        // run the operation
        (*oper.op)(oper.data);
        // need to terminate?
        if (opFlags & FLAG_TERM) {
            // leave the loop to perform cleanup
            break;
        }
        // check for more stuff queued
        if (queueLen) {
            // do not wait on the condition; continue with the next operation
            // now
            goto ioThread_noWait;
        }
    }
    SDL_DestroyMutex(waitMutex);
    SDL_DestroyMutex(queueMutex);
    queueMutex = NULL;
    return 0;
}

void StartIOThread() {
    // create the condition gizmo used to signal the I/O thread
    notify = SDL_CreateCond();
    // start the I/O thread
    thread = SDL_CreateThread(ioThread, NULL);
    // avoid possible race conditions by allowing the thread some time to
    // initalize itself
    SDL_Delay(2);
}

void StopIOThread() {
    // see if the thread was started and a queue mutex exists
    if (thread && queueMutex) {
        // The thread was started and should be running. Try to lock the queue.
        if (SDL_mutexP(queueMutex) == -1) {
            // kill the thread forcefully.
            EndIOThread_kill:
            SDL_KillThread(thread);
            //printf("Forced end of IO thread\n");
        }
        else {
            // remove the last item from the queue
            queueLen = 0;
            // request than any operation in progess please quit
            opFlags = FLAG_CANCEL | FLAG_TERM;
            // release the queue lock
            SDL_mutexV(queueMutex);
            // signal the thread
            if (SDL_CondSignal(notify) == -1) {
                // couldn't do it; assure a dead thread
                goto EndIOThread_kill;
            }
            // wait for the thread to finish
            SDL_WaitThread(thread, NULL);
            //printf("Normal end of IO thread\n");
        }
        thread = NULL;
    }
    SDL_DestroyCond(notify);
}

int QueueOperation(ioOperation op, void *data) {
    int ret;
    // the queue should already exist
    assert(queueMutex != NULL);
    // check for full queue
    if (queueLen == IO_QUEUE_SIZE)
        return -1;
    // attempt to lock the queue
    if (SDL_mutexP(queueMutex) == -1) {
        // failed
        return -2;
    }
    // compute new length
    ret = ++queueLen;
    // compute the index of the new item
    queueNext = (queueNext + 1) % IO_QUEUE_SIZE;
    // add the item
    queue[queueNext].op = op;
    queue[queueNext].data = data;
    // signal the thread
    SDL_CondSignal(notify);
    // release the lock
    SDL_mutexV(queueMutex);
    // send back the remaining queue length
    return ret;
}

Bool IsCancelationRequested() {
    return opFlags & FLAG_CANCEL;
}

Bool CancelOperations() {
    // see if the thread was started and a queue mutex exists
    if (thread && queueMutex) {
        // The thread was started and should be running. Try to lock the queue.
        if (SDL_mutexP(queueMutex) != -1) {
            // remove the last item from the queue
            queueLen = 0;
            // request than any operation in progess please quit
            opFlags = FLAG_CANCEL;
            // release the queue lock
            SDL_mutexV(queueMutex);
            // sucess
            return TRUE;
        }
    }
    // failed
    return FALSE;
}

---