/*
* 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 "CWatchDogThread.h"
#include "Events/CWatchDogFeedbackEvent.h"
#include "Events/CRequestFeedbackEvent.h"
namespace Konclude {
namespace Concurrent {
CWatchDogThread * CWatchDogThread::watchDogInstance = 0;
QSemaphore * CWatchDogThread::syncSemaphore = new QSemaphore(1);
CWatchDogThread::CWatchDogThread() : CIntervalThread("WatchDog") {
startThread();
currentUpdateNumber = 0;
}
CWatchDogThread::~CWatchDogThread() {
stopThread();
}
CWatchDogThread *CWatchDogThread::getInstance() {
if (watchDogInstance == 0) {
syncSemaphore->acquire();
if (watchDogInstance == 0) {
watchDogInstance = new CWatchDogThread();
}
syncSemaphore->release();
}
return watchDogInstance;
}
bool CWatchDogThread::registerThread(CThread *thread) {
regSync.lockForWrite();
qint64 threadID = thread->getThreadID();
CWatchDogThreadData *data = 0;
if (threadWatch.contains(threadID)) {
data = threadWatch.value(threadID);
} else {
data = new CWatchDogThreadData();
threadWatch.insert(threadID,data);
data->setRegisterThread(true);
data->setThreadID(threadID);
data->setThreadName(thread->getThreadName());
data->setThread(thread);
}
data->setThreadActive(true);
data->setRunTime(thread->getRunTimeSecs());
data->setWaitTime(thread->getWaitTimeSecs());
data->setTaskDescription(thread->getTaskDescription());
regSync.unlock();
return true;
}
void CWatchDogThread::feedbackThread(CThread *thread, qint64 updateNumber) {
CWatchDogFeedbackEvent *wdFEvent = new CWatchDogFeedbackEvent(thread->getThreadID(),updateNumber);
postEvent(wdFEvent);
}
void CWatchDogThread::checkoutThread(CThread *thread) {
regSync.lockForWrite();
qint64 threadID = thread->getThreadID();
CWatchDogThreadData *data = 0;
if (threadWatch.contains(threadID)) {
data = threadWatch.value(threadID);
} else {
data = new CWatchDogThreadData();
threadWatch.insert(threadID,data);
data->setRegisterThread(true);
data->setThreadID(threadID);
data->setThreadName(thread->getThreadName());
data->setThread(thread);
}
data->setThreadActive(false);
data->setThreadError(false);
data->setRunTime(thread->getRunTimeSecs());
data->setWaitTime(thread->getWaitTimeSecs());
data->setTaskDescription(thread->getTaskDescription());
regSync.unlock();
}
void CWatchDogThread::crashedThread(CThread *thread) {
regSync.lockForWrite();
qint64 threadID = thread->getThreadID();
CWatchDogThreadData *data = 0;
if (threadWatch.contains(threadID)) {
data = threadWatch.value(threadID);
} else {
data = new CWatchDogThreadData();
threadWatch.insert(threadID,data);
data->setRegisterThread(true);
data->setThreadID(threadID);
data->setThreadName(thread->getThreadName());
data->setThread(thread);
}
data->setThreadActive(false);
data->setThreadError(true);
data->setRunTime(thread->getRunTimeSecs());
data->setWaitTime(thread->getWaitTimeSecs());
data->setTaskDescription(thread->getTaskDescription());
regSync.unlock();
}
QLinkedList CWatchDogThread::getActiveThreadList() {
QLinkedList retDataList;
regSync.lockForRead();
QList threadList = threadWatch.values();
foreach (CWatchDogThreadData *threadData, threadList) {
if (threadData->isThreadActive()) {
retDataList.append(*threadData);
}
}
regSync.unlock();
return retDataList;
}
// Thread functions
void CWatchDogThread::threadStarted() {
CIntervalThread::threadStarted();
startTimerWithInterval(REQUESTFEEDBACKTIMERID,1000);
startTimerWithInterval(UPDATETHREADINFOTIMERID,500);
}
bool CWatchDogThread::processCustomsEvents(QEvent::Type type, CCustomEvent *event) {
if (CIntervalThread::processCustomsEvents(type,event)) {
return true;
} if (type == EVENTFEEDBACKTHREADWATCHDOG) {
SETTASKDESCRIPTION("Process Thread Feedback");
CWatchDogFeedbackEvent *wdfe = (CWatchDogFeedbackEvent *)event;
regSync.lockForWrite();
qint64 threadID = wdfe->getThreadID();
qint64 uNr = wdfe->getUpdateNumber();
CWatchDogThreadData *data = 0;
if (threadWatch.contains(threadID)) {
data = threadWatch.value(threadID);
}
if (data) {
data->setUpdateNumber(uNr,QDateTime::currentDateTime());
}
regSync.unlock();
return true;
}
return false;
}
bool CWatchDogThread::processTimer(qint64 timerID) {
if (timerID == REQUESTFEEDBACKTIMERID) {
SETTASKDESCRIPTION("Request Thread Feedbacks");
regSync.lockForRead();
QList threadList = threadWatch.values();
foreach (CWatchDogThreadData *threadData, threadList) {
if (threadData->isThreadActive()) {
CThread *thread = threadData->getThread();
sendRequestFeedbackEvent(thread,currentUpdateNumber);
}
}
regSync.unlock();
currentUpdateNumber++;
return true;
} else if (timerID == UPDATETHREADINFOTIMERID) {
SETTASKDESCRIPTION("Update Thread Informations");
regSync.lockForWrite();
QList threadList = threadWatch.values();
foreach (CWatchDogThreadData *threadData, threadList) {
if (threadData->isThreadActive()) {
CThread *thread = threadData->getThread();
updateThreadData(thread,threadData);
}
}
regSync.unlock();
return true;
}
return false;
}
void CWatchDogThread::sendRequestFeedbackEvent(CThread *thread, qint64 uNr) {
thread->postEvent(new CRequestFeedbackEvent(this,uNr));
}
void CWatchDogThread::updateThreadData(CThread *thread, CWatchDogThreadData *threadData) {
threadData->setTaskDescription(thread->getTaskDescription());
threadData->setRunTime(thread->getRunTimeSecs());
threadData->setWaitTime(thread->getWaitTimeSecs());
}
}; // end namespace Concurrent
}; // end namespace Konclude