vthread.cpp

Go to the documentation of this file.

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 4.1
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#include "vthread.h"

#include <exception>
#include "vexception.h"
#include "vmanagementinterface.h"
#include "vlogger.h"
#include "vmutexlocker.h"
#include "vbento.h"

// This private map allows us to keep track of all VThread objects, and therefore to
// find the current thread's VThread object from the thread ID. We also have an API
// to get info about all these threads.
typedef std::map<VThreadID_Type, VThread*> VThreadIDToVThreadMap;
VThreadIDToVThreadMap gVThreadIDToVThreadMap;
static VMutex gVThreadMapMutex("gVThreadMapMutex", true/*suppress logging because logging itself uses this*/);

static void _vthreadStarting(VThread* thread) {
    VMutexLocker locker(&gVThreadMapMutex, "_vthreadStarting");
    gVThreadIDToVThreadMap[thread->threadID()] = thread;
}

static void _vthreadEnded(VThread* thread) {
    VMutexLocker locker(&gVThreadMapMutex, "_vthreadEnded");
    VThreadIDToVThreadMap::iterator position = gVThreadIDToVThreadMap.find(thread->threadID());
    if (position != gVThreadIDToVThreadMap.end())
        gVThreadIDToVThreadMap.erase(position);
}

class VStandinThread : public VThread {
    public:
        VStandinThread() : VThread("?", "vault.threads.VStandinThread", false, false, NULL) {}
        virtual ~VStandinThread() {}
        virtual void run() {}
};

static VStandinThread gStandinThread;

static VThread* _getCurrentVThread() {
    VThreadID_Type currentThreadID = VThread::threadSelf();
    VMutexLocker locker(&gVThreadMapMutex, "_getCurrentVThread");
    VThreadIDToVThreadMap::const_iterator position = gVThreadIDToVThreadMap.find(currentThreadID);
    if (position == gVThreadIDToVThreadMap.end())
        return &gStandinThread; // If called from main thread, or non-VThread-derived thread, we won't find a VThread. This allows us to return something workable to any caller.

    return (*position).second;
    // Note: once we return, the thread could stop.
    // But since this is called from the current thread, it really can't disappear while caller lives.
    // It just can't be passed around to other threads!
}

VThread::VThread(const VString& name, const VString& loggerName, bool deleteAtEnd, bool createDetached, VManagementInterface* manager)
    : mIsDeleted(false)
    , mName(name)
    , mLoggerName(loggerName)
    , mDeleteAtEnd(deleteAtEnd)
    , mCreateDetached(createDetached)
    , mManager(manager)
    , mThreadID((VThreadID_Type) - 1)
    , mIsRunning(false)
    {
}

VThread::~VThread() {
    // Detect repeat deletion bug. Can't refer to mName because it's been deleted.
    if (mIsDeleted)
        VLOGGER_NAMED_ERROR(mLoggerName, VSTRING_FORMAT("Thread delete on already-deleted thread @0x%08X.", this));

    mIsDeleted = true;
    mIsRunning = false;
    mThreadID = (VThreadID_Type) - 1;
}

void VThread::start() {
    if (mIsRunning) {
        return;
    }

    mIsRunning = true;

    try {
        VThread::threadCreate(&mThreadID, mCreateDetached, VThread::userThreadMain, (void*) this);
    } catch (...) {
        mIsRunning = false;
        throw;
    }
}

void VThread::stop() {
    mIsRunning = false;
}

VThreadID_Type VThread::threadID() const {
    return mThreadID;
}

bool VThread::isRunning() const {
    return mIsRunning;
}

bool VThread::join() {
    // FIXME: could complain here if mCreateDetached is true.

    if (! mIsRunning || (mThreadID == (VThreadID_Type) - 1)) {
        return true;    // never started, or was stopped, so we're done
    } else {
        return VThread::threadJoin(mThreadID, NULL);
    }
}

bool VThread::getDeleteAtEnd() const {
    return mDeleteAtEnd;
}

VManagementInterface* VThread::getManagementInterface() const {
    return mManager;
}

#ifdef VAULT_SIMPLE_USER_THREAD_MAIN
void* VThread::userThreadMain(void* arg) {
    return VThread::threadMain(arg);
}
#endif

void* VThread::threadMain(void* arg) {
    VThread*    thread = static_cast<VThread*>(arg);
    VString     threadName = thread->getName();
    VString     threadLoggerName = thread->getLoggerName();

    VLOGGER_NAMED_TRACE(threadLoggerName, VSTRING_FORMAT("VThread::threadMain: start of thread '%s' id 0x%08X.", threadName.chars(), thread->threadID()));

    bool        deleteAtEnd = thread->getDeleteAtEnd();

    VManagementInterface* manager = thread->getManagementInterface();

    try {
        VAutoreleasePool pool;
        _vthreadStarting(thread);
        VThread::_threadStarting(thread);

        if (manager != NULL) {
            manager->threadStarting(thread);
        }

        thread->run();
    } catch (const VException& ex) {
        VLOGGER_NAMED_ERROR(threadLoggerName, VSTRING_FORMAT("Thread '%s' main caught exception #%d '%s'.", threadName.chars(), ex.getError(), ex.what()));
    } catch (const std::exception& ex) {
        VLOGGER_NAMED_ERROR(threadLoggerName, VSTRING_FORMAT("Thread '%s' main caught exception '%s'.", threadName.chars(), ex.what()));
    } catch (...) {
        VLOGGER_NAMED_ERROR(threadLoggerName, VSTRING_FORMAT("Thread '%s' main caught unknown exception.", threadName.chars()));
    }

    // Let's be bulletproof even on this notification -- use try/catch.
    try {
        if (manager != NULL) {
            VLOGGER_NAMED_TRACE(threadLoggerName, VSTRING_FORMAT("VThread '%s' notifying manager[0x%08X] of thread end.", threadName.chars(), manager));
            manager->threadEnded(thread);
        }
    } catch (...) {
        VLOGGER_NAMED_ERROR(threadLoggerName, VSTRING_FORMAT("Thread '%s' main caught exception notifying manager of thread end.", threadName.chars()));
    }

    VThread::_threadEnded(thread);
    _vthreadEnded(thread);

    if (deleteAtEnd) {
        delete thread;
    }

    VLOGGER_NAMED_TRACE(threadLoggerName, VSTRING_FORMAT("VThread::threadMain: completed thread '%s'.", threadName.chars()));

    return NULL;
}

// static
VThread* VThread::getCurrentThread() {
    return _getCurrentVThread();
}

// static
VString VThread::getCurrentThreadName() {
    VThread* currentThread = VThread::getCurrentThread();
    if (currentThread != &gStandinThread) {
        return currentThread->getName();
    }

    // It's the stand-in thread for non-VThread threads. Its name is meaningless.
    // Format the current OS thread ID.
    Vs64 id64 = (Vs64) VThread::threadSelf();
    return VSTRING_S64(id64);
}

// static
void VThread::getThreadsInfo(VBentoNode& bento) {
    bento.setName("threads");

    VMutexLocker locker(&gVThreadMapMutex, "VThread::getThreadsInfo");
    for (VThreadIDToVThreadMap::const_iterator i = gVThreadIDToVThreadMap.begin(); i != gVThreadIDToVThreadMap.end(); ++i) {
        VThread* thread = (*i).second;
        VBentoNode* child = bento.addNewChildNode("thread");
        child->addString("name", thread->getName());
        child->addS64("threadID", reinterpret_cast<Vs64>((void*) thread->mThreadID)); // Convoluted casting to make all platforms happy showing different id types as a 64-bit number.
        child->addBool("isRunning", thread->mIsRunning);
        child->addBool("isDeleted", thread->mIsDeleted);
        child->addBool("deleteAtEnd", thread->mDeleteAtEnd);
        child->addBool("createdDetached", thread->mCreateDetached);
        child->addBool("hasManager", thread->mManager != NULL);
    }
}

// static
VString VThread::getThreadName(VThreadID_Type threadID) {
    VMutexLocker locker(&gVThreadMapMutex, "VThread::getThreadName");
    VThreadIDToVThreadMap::iterator position = gVThreadIDToVThreadMap.find(threadID);
    if (position == gVThreadIDToVThreadMap.end()) {
        return VString::EMPTY();
    }

    VThread* thread = (*position).second;
    VString threadName = thread->getName();
    return threadName;
}

// static
void VThread::stopThread(VThreadID_Type threadID) {
    VMutexLocker locker(&gVThreadMapMutex, "VThread::stopThread");
    VThreadIDToVThreadMap::iterator position = gVThreadIDToVThreadMap.find(threadID);
    if (position != gVThreadIDToVThreadMap.end()) {
        VThread* thread = (*position).second;
        thread->stop();
    }
}

#ifndef VAULT_USER_STACKCRAWL_SUPPORT
// static
void VThread::logStackCrawl(const VString& headerMessage, VNamedLoggerPtr logger, bool /*verbose*/) {
    if (logger == nullptr) {
        VLOGGER_ERROR(VSTRING_FORMAT("%s (VThread::logStackCrawl: User stack crawl not implemented.)", headerMessage.chars()));
    } else {
        logger->emitStackCrawlLine(VSTRING_FORMAT("%s (VThread::logStackCrawl: User stack crawl not implemented.)", headerMessage.chars()));
    }
}
#endif /* VAULT_USER_STACKCRAWL_SUPPORT */

// VMainThread ----------------------------------------------------------------

VMainThread::VMainThread()
    : VThread("main", "vault.threads.VMainThread", kDontDeleteSelfAtEnd, kCreateThreadJoinable/*doesn't matter*/, NULL)
    {
    mThreadID = VThread::threadSelf();
    _vthreadStarting(this); // Register this object for lookup by mThreadID.
}

VMainThread::~VMainThread() {
    _vthreadEnded(this); // De-register this object.
}

void VMainThread::start() {
    VString errorMessage("Error: invalid attempt to start VMainThread.");
    VLOGGER_NAMED_FATAL(mLoggerName, errorMessage);
    throw VStackTraceException(errorMessage);
}

int VMainThread::execute(int argc, char** argv) {
    return VThread::userMain(argc, argv);
}

// VForeignThread ----------------------------------------------------------------

VForeignThread::VForeignThread(const VString& name)
    : VThread(name, "vault.threads.VForeignThread", kDontDeleteSelfAtEnd, kCreateThreadJoinable/*doesn't matter*/, NULL)
    {
    mThreadID = VThread::threadSelf();
    _vthreadStarting(this); // Register this object for lookup by mThreadID.
}

VForeignThread::~VForeignThread() {
    _vthreadEnded(this); // De-register this object.
}

void VForeignThread::start() {
    VString errorMessage("Error: invalid attempt to start VForeignThread.");
    VLOGGER_NAMED_FATAL(mLoggerName, errorMessage);
    throw VStackTraceException(errorMessage);
}