/* * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. * * This file is part of the reasoning system Konclude. * For details and support, see . * * Konclude is free software: you can redistribute it and/or modify * it under the terms of version 3 of the GNU Lesser General Public * License (LGPLv3) as published by the Free Software Foundation. * * Konclude is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU (Lesser) General Public License for more details. * * You should have received a copy of the GNU (Lesser) General Public * License along with Konclude. If not, see . * */ #include "CThread.h" #include "Events/CRequestFeedbackEvent.h" #include "Logger/CLogger.h" namespace Konclude { namespace Concurrent { qint64 CThread::nextThreadID = 1; QSemaphore *CThread::syncThreadID = new QSemaphore(1); CThread::CThread(QString threadIdentifierName, CWatchDog *watchDogThread) { threadName = threadIdentifierName; waitTimeSecs = 0; blockTimeSecs = 0; runTimeSecs = 0; threadID = 0; mWatchDog = watchDogThread; threadRuns = false; mActiveEventProcessing = false; } CThread::~CThread() { stopThread(true); } void CThread::setTaskDescription(QString description) { lastTaskDescription = taskDescription; taskDescription = description; } QString CThread::getLastTaskDescription() { return lastTaskDescription; } QString CThread::getTaskDescription() { return taskDescription; } QString CThread::getThreadName() { return threadName; } qint64 CThread::getWaitTimeSecs() { return waitTimeSecs; } qint64 CThread::getRunTimeSecs() { return runTimeSecs; } qint64 CThread::getBlockTimeSecs() { return blockTimeSecs; } qint64 CThread::getThreadID() { return threadID; } void CThread::postEvent(QEvent *event, int priority) { QCoreApplication::postEvent(this,event,priority); } void CThread::waitSynchronization() { QSemaphore syncSemaphore(0); postEvent(new CWaitSynchronizationEvent(&syncSemaphore)); syncSemaphore.acquire(); } bool CThread::isThreadRunning() { return threadRuns; } void CThread::restartThread() { terminate(); wait(); startThread(); } void CThread::run() { bool registerd = false; try { // get thread id syncThreadID->acquire(); threadID = nextThreadID++; syncThreadID->release(); // register thread to watchdog if (mWatchDog) { registerd = mWatchDog->registerThread(this); } // workload measurement TIMEMEASUREMENTBEGINWAITING(); threadStarted(); threadRuns = true; exec(); threadRuns = false; threadStopped(); // workload measurement TIMEMEASUREMENTENDWAITING(); if (mWatchDog) { mWatchDog->checkoutThread(this); } } catch (...) { if (mWatchDog) { mWatchDog->crashedThread(this); } } } void CThread::prepareExecution() { runTimer.start(); } void CThread::concludeExecution() { runTimeSecs += runTimer.elapsed(); } void CThread::prepareWaiting() { waitTimer.start(); } void CThread::concludeWaiting() { waitTimeSecs += waitTimer.elapsed(); } bool CThread::event(QEvent *event) { try { // workload measurement TIMEMEASUREMENTENDWAITING(); TIMEMEASUREMENTBEGINEXECUTION(); SETTASKDESCRIPTION("Start Processing Events"); mActiveEventProcessing = true; bool processed = processEvents(event); if (!processed) { // event processing QEvent::Type type = event->type(); if (type >= 1200 && type < 2000) { processControlEvents(type,(CControlEvent *)event); processed = true; } else if (type >= 2000) { processCustomsEvents(type,(CCustomEvent *)event); processed = true; } } mActiveEventProcessing = false; // workload measurement TIMEMEASUREMENTENDEXECUTION(); TIMEMEASUREMENTBEGINWAITING(); SETTASKDESCRIPTION("Wait for Events"); return processed; } catch (exception& e) { LOG(ERROR, "::Konclude::Thread", logTr("Unhandled standard exception %1, thread %2 stopped.").arg(e.what()).arg(threadName), this); return false; } catch (...) { LOG(ERROR,"::Konclude::Thread",logTr("Unhandled exception, thread %1 stopped.").arg(threadName),this); return false; } } bool CThread::isThreadProcessingEvents() { return mActiveEventProcessing; } void CThread::prepareBlocking() { runTimeSecs += runTimer.elapsed(); blockTimer.start(); } void CThread::concludeBlocking() { blockTimeSecs += blockTimer.elapsed(); runTimer.start(); } void CThread::threadStarted() { } void CThread::threadStopped() { } void CThread::startThread(Priority priority) { start(priority); moveToThread(this); } void CThread::stopThread(bool waitStopped) { quit(); if (waitStopped) { wait(); } } bool CThread::processEvents(QEvent *event) { return false; } bool CThread::processCustomsEvents(QEvent::Type type, CCustomEvent *event) { return false; } bool CThread::processControlEvents(QEvent::Type type, CControlEvent *event) { if (type == EVENTREQUESTFEEDBACKWATCHDOG) { SETTASKDESCRIPTION("Send WatchDog Feedback"); CRequestFeedbackEvent *rfe = (CRequestFeedbackEvent *)event; CWatchDog *watchDog = (CWatchDog *)rfe->getWatchDogThread(); qint64 updateNumber = rfe->getUpdateNumber(); watchDog->feedbackThread(this,updateNumber); return true; } else if (type == EVENTWAITSYNCHRONIZATION) { SETTASKDESCRIPTION("Synchronize"); CWaitSynchronizationEvent *wse = (CWaitSynchronizationEvent *)event; wse->synchronize(); return true; } return false; } }; // end namespace Concurrent }; // end namespace Konclude