Merge remote-tracking branch 'origin/development' into gaisser_make_linux_realtime_optional

osal/host/CMakeLists.txt

@@ -10,6 +10,7 @@ target_sources(${LIB_FSFW_NAME}
 		QueueMapManager.cpp
 		SemaphoreFactory.cpp
 		TaskFactory.cpp
+		taskHelpers.cpp
 )
 
 if(UNIX)

osal/host/FixedTimeslotTask.cpp

@@ -1,10 +1,9 @@
+#include "taskHelpers.h"
 #include "../../osal/host/FixedTimeslotTask.h"
-
 #include "../../ipc/MutexFactory.h"
 #include "../../osal/host/Mutex.h"
 #include "../../osal/host/FixedTimeslotTask.h"
-
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../tasks/ExecutableObjectIF.h"
 
 #include <thread>
@@ -12,6 +11,7 @@
 
 #if defined(WIN32)
 #include <windows.h>
+#include "../windows/winTaskHelpers.h"
 #elif defined(LINUX)
 #include <pthread.h>
 #endif
@@ -24,34 +24,12 @@ FixedTimeslotTask::FixedTimeslotTask(const char *name, TaskPriority setPriority,
     // It is propably possible to set task priorities by using the native
     // task handles for Windows / Linux
     mainThread = std::thread(&FixedTimeslotTask::taskEntryPoint, this, this);
-#if defined(WIN32)
-    /* List of possible priority classes:
-     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
-     * nf-processthreadsapi-setpriorityclass
-     * And respective thread priority numbers:
-     * https://docs.microsoft.com/en-us/windows/
-     * win32/procthread/scheduling-priorities */
-    int result = SetPriorityClass(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            ABOVE_NORMAL_PRIORITY_CLASS);
-    if(result != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-#endif
-    }
-    result = SetThreadPriority(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            THREAD_PRIORITY_NORMAL);
-    if(result != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "FixedTimeslotTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-#endif
-    }
-#elif defined(LINUX)
-    // TODO: we can just copy and paste the code from the linux OSAL here.
+#if defined(_WIN32)
+    tasks::setTaskPriority(reinterpret_cast<HANDLE>(mainThread.native_handle()), setPriority);
+#elif defined(__unix__)
+    // TODO: We could reuse existing code here.
 #endif
+    tasks::insertTaskName(mainThread.get_id(), taskName);
 }
 
 FixedTimeslotTask::~FixedTimeslotTask(void) {
@@ -60,7 +38,6 @@ FixedTimeslotTask::~FixedTimeslotTask(void) {
     if(mainThread.joinable()) {
         mainThread.join();
     }
-    delete this;
 }
 
 void FixedTimeslotTask::taskEntryPoint(void* argument) {
@@ -141,8 +118,11 @@ ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
     }
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "Component " << std::hex << componentId <<
-            " not found, not adding it to pst" << std::endl;
+    sif::error << "Component " << std::hex << "0x" << componentId << "not found, "
+            "not adding it to PST.." << std::dec << std::endl;
+#else
+    sif::printError("Component 0x%08x not found, not adding it to PST..\n",
+            static_cast<unsigned int>(componentId));
 #endif
     return HasReturnvaluesIF::RETURN_FAILED;
 }

osal/host/MessageQueue.cpp

@@ -3,7 +3,7 @@
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../ipc/MutexFactory.h"
-#include "../../ipc/MutexHelper.h"
+#include "../../ipc/MutexGuard.h"
 
 MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		messageSize(maxMessageSize), messageDepth(messageDepth) {
@@ -63,9 +63,7 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
 	if(messageQueue.empty()) {
 		return MessageQueueIF::EMPTY;
 	}
-	// not sure this will work..
-	//*message = std::move(messageQueue.front());
-	MutexHelper mutexLock(queueLock, MutexIF::TimeoutType::WAITING, 20);
+	MutexGuard mutexLock(queueLock, MutexIF::TimeoutType::WAITING, 20);
 	MessageQueueMessage* currentMessage = &messageQueue.front();
 	std::copy(currentMessage->getBuffer(),
 			currentMessage->getBuffer() + messageSize, message->getBuffer());
@@ -130,7 +128,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	if(targetQueue->messageQueue.size() < targetQueue->messageDepth) {
-		MutexHelper mutexLock(targetQueue->queueLock,
+		MutexGuard mutexLock(targetQueue->queueLock,
 		        MutexIF::TimeoutType::WAITING, 20);
 		// not ideal, works for now though.
 		MessageQueueMessage* mqmMessage =

osal/host/MutexFactory.cpp

@@ -24,5 +24,7 @@ MutexIF* MutexFactory::createMutex() {
 }
 
 void MutexFactory::deleteMutex(MutexIF* mutex) {
-	delete mutex;
+    if(mutex != nullptr) {
+        delete mutex;
+    }
 }

osal/host/PeriodicTask.cpp

@@ -1,5 +1,6 @@
 #include "Mutex.h"
 #include "PeriodicTask.h"
+#include "taskHelpers.h"
 
 #include "../../ipc/MutexFactory.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
@@ -10,7 +11,8 @@
 
 #if defined(WIN32)
 #include <processthreadsapi.h>
-#elif defined(LINUX)
+#include <fsfw/osal/windows/winTaskHelpers.h>
+#elif defined(__unix__)
 #include <pthread.h>
 #endif
 
@@ -22,34 +24,12 @@ PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
     // It is probably possible to set task priorities by using the native
     // task handles for Windows / Linux
 	mainThread = std::thread(&PeriodicTask::taskEntryPoint, this, this);
-#if defined(WIN32)
-    /* List of possible priority classes:
-     * https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/
-     * nf-processthreadsapi-setpriorityclass
-     * And respective thread priority numbers:
-     * https://docs.microsoft.com/en-us/windows/
-     * win32/procthread/scheduling-priorities */
-    int result = SetPriorityClass(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            ABOVE_NORMAL_PRIORITY_CLASS);
-    if(result != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-#endif
-    }
-    result = SetThreadPriority(
-            reinterpret_cast<HANDLE>(mainThread.native_handle()),
-            THREAD_PRIORITY_NORMAL);
-    if(result != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "PeriodicTask: Windows SetPriorityClass failed with code "
-                << GetLastError() << std::endl;
-#endif
-    }
-#elif defined(LINUX)
-    // we can just copy and paste the code from linux here.
+#if defined(_WIN32)
+	tasks::setTaskPriority(reinterpret_cast<HANDLE>(mainThread.native_handle()), setPriority);
+#elif defined(__unix__)
+    // TODO: We could reuse existing code here.
 #endif
+    tasks::insertTaskName(mainThread.get_id(), taskName);
 }
 
 PeriodicTask::~PeriodicTask(void) {
@@ -58,7 +38,6 @@ PeriodicTask::~PeriodicTask(void) {
 	if(mainThread.joinable()) {
 		mainThread.join();
 	}
-	delete this;
 }
 
 void PeriodicTask::taskEntryPoint(void* argument) {

osal/host/QueueMapManager.cpp

@@ -2,7 +2,7 @@
 
 #include "../../serviceinterface/ServiceInterface.h"
 #include "../../ipc/MutexFactory.h"
-#include "../../ipc/MutexHelper.h"
+#include "../../ipc/MutexGuard.h"
 
 QueueMapManager* QueueMapManager::mqManagerInstance = nullptr;
 
@@ -10,6 +10,10 @@ QueueMapManager::QueueMapManager() {
     mapLock = MutexFactory::instance()->createMutex();
 }
 
+QueueMapManager::~QueueMapManager() {
+    MutexFactory::instance()->deleteMutex(mapLock);
+}
+
 QueueMapManager* QueueMapManager::instance() {
 	if (mqManagerInstance == nullptr){
 		mqManagerInstance = new QueueMapManager();
@@ -43,7 +47,7 @@ ReturnValue_t QueueMapManager::addMessageQueue(
 
 MessageQueueIF* QueueMapManager::getMessageQueue(
 		MessageQueueId_t messageQueueId) const {
-	MutexHelper(mapLock, MutexIF::TimeoutType::WAITING, 50);
+	MutexGuard(mapLock, MutexIF::TimeoutType::WAITING, 50);
 	auto queueIter = queueMap.find(messageQueueId);
 	if(queueIter != queueMap.end()) {
 		return queueIter->second;

osal/host/QueueMapManager.h

@@ -36,6 +36,8 @@ public:
 private:
 	//! External instantiation is forbidden.
 	QueueMapManager();
+	~QueueMapManager();
+
 	uint32_t queueCounter = 0;
 	MutexIF* mapLock;
 	QueueMap queueMap;

osal/host/SemaphoreFactory.cpp

@@ -1,7 +1,5 @@
 #include "../../tasks/SemaphoreFactory.h"
-#include "../../osal/linux/BinarySemaphore.h"
-#include "../../osal/linux/CountingSemaphore.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
 

osal/host/TaskFactory.cpp

@@ -1,14 +1,16 @@
+#include "taskHelpers.h"
+#include "../../tasks/TaskFactory.h"
 #include "../../osal/host/FixedTimeslotTask.h"
 #include "../../osal/host/PeriodicTask.h"
-#include "../../tasks/TaskFactory.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include "../../tasks/PeriodicTaskIF.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 #include <chrono>
 
 TaskFactory* TaskFactory::factoryInstance = new TaskFactory();
 
-// Will propably not be used for hosted implementation
+// Not used for the host implementation for now because C++ thread abstraction is used
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = 0;
 
 TaskFactory::TaskFactory() {
@@ -49,8 +51,12 @@ ReturnValue_t TaskFactory::delayTask(uint32_t delayMs){
 }
 
 void TaskFactory::printMissedDeadline() {
-    /* TODO: Implement */
-    return;
+    std::string name = tasks::getTaskName(std::this_thread::get_id());
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "TaskFactory::printMissedDeadline: " << name << std::endl;
+#else
+    sif::printWarning("TaskFactory::printMissedDeadline: %s\n", name);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 }
 
 

osal/host/taskHelpers.cpp

@@ -0,0 +1,27 @@
+#include "taskHelpers.h"
+#include <map>
+#include <mutex>
+
+std::mutex nameMapLock;
+std::map<std::thread::id, std::string> taskNameMap;
+
+ReturnValue_t tasks::insertTaskName(std::thread::id threadId, std::string taskName) {
+    std::lock_guard<std::mutex> lg(nameMapLock);
+    auto returnPair = taskNameMap.emplace(threadId, taskName);
+    if(not returnPair.second) {
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+}
+
+std::string tasks::getTaskName(std::thread::id threadId) {
+    std::lock_guard<std::mutex> lg(nameMapLock);
+    auto resultIter = taskNameMap.find(threadId);
+    if(resultIter != taskNameMap.end()) {
+        return resultIter->second;
+    }
+    else {
+        return "Unknown task";
+    }
+}
+

osal/host/taskHelpers.h

@@ -0,0 +1,16 @@
+#ifndef FSFW_OSAL_HOST_TASKHELPERS_H_
+#define FSFW_OSAL_HOST_TASKHELPERS_H_
+
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <thread>
+
+namespace tasks {
+
+ReturnValue_t insertTaskName(std::thread::id threadId, std::string taskName);
+std::string getTaskName(std::thread::id threadId);
+
+}
+
+
+
+#endif /* FSFW_OSAL_HOST_TASKHELPERS_H_ */