#5 back fill testing into project to ensure good coverage. Now quite well tested.

Author: dave

src/TaskBlock.h

@@ -0,0 +1,66 @@
+//
+// Created by David Cherry on 28/08/2020.
+//
+
+#ifndef _TASKMANAGERIO_TASKBLOCK_H_
+#define _TASKMANAGERIO_TASKBLOCK_H_
+
+#include <TaskPlatformDeps.h>
+#include <TaskTypes.h>
+
+/**
+ * This is an internal class, and users of the library generally don't see it.
+ *
+ * Task manager can never deallocate memory that it has already allocated for tasks, this is in order to make thread
+ * safety much easier. Given this we allocate tasks in blocks of DEFAULT_TASK_SIZE and each tranche contains it's start
+ * and end point in the "array". DEFAULT task size is set to 20 on 32 bit hardware where the size is negligible, 10
+ * on MEGA2560 and all other AVR boards default to 6. We allow up to 8 tranches on AVR and up to 16 on 32 bit boards.
+ * This should provide more than enough tasks for most boards.
+ */
+class TaskBlock {
+private:
+    TimerTask tasks[DEFAULT_TASK_SIZE];
+    const taskid_t first;
+    const taskid_t arraySize;
+public:
+    explicit TaskBlock(taskid_t first_) : first(first_), arraySize(DEFAULT_TASK_SIZE) {}
+
+    /**
+     * Checks if taskId is contained within this block
+     * @param task the task ID to check
+     * @return true if contained, otherwise false
+     */
+    bool isTaskContained(taskid_t task) const {
+        return task >= first && task < (first + arraySize);
+    };
+
+    TimerTask* getContainedTask(taskid_t task) {
+        return isTaskContained(task) ? &tasks[task - first] : nullptr;
+    }
+
+    void clearAll() {
+        for(taskid_t i=0; i<arraySize;i++) {
+            tasks[i].clear();
+        }
+    }
+
+    taskid_t allocateTask() {
+        for(taskid_t i=0; i<arraySize; i++) {
+            if(tasks[i].allocateIfPossible()) {
+                return i + first;
+            }
+        }
+        return TASKMGR_INVALIDID;
+    }
+
+    taskid_t lastSlot() const {
+        return first + arraySize - 1;
+    }
+
+    taskid_t firstSlot() const {
+        return first;
+    }
+};
+
+
+#endif //_TASKMANAGERIO_TASKBLOCK_H_

src/TaskManager.cpp

@@ -101,7 +101,7 @@ taskid_t TaskManager::scheduleOnce(uint32_t when, TimerFn timerFunction, TimerUn
 	auto taskId = findFreeTask();
 	if (taskId != TASKMGR_INVALIDID) {
         auto task = getTask(taskId);
-        task->initialise(when, timeUnit, timerFunction);
+        task->initialise(when, timeUnit, timerFunction, false);
 		putItemIntoQueue(task);
 	}
 	return taskId;
@@ -111,7 +111,7 @@ taskid_t TaskManager::scheduleFixedRate(uint32_t when, TimerFn timerFunction, Ti
 	auto taskId = findFreeTask();
 	if (taskId != TASKMGR_INVALIDID) {
         auto task = getTask(taskId);
-        task->initialise(when, TimerUnit(timeUnit | TM_TIME_REPEATING), timerFunction);
+        task->initialise(when, timeUnit, timerFunction, true);
 		putItemIntoQueue(task);
 	}
 	return taskId;
@@ -121,7 +121,7 @@ taskid_t TaskManager::scheduleOnce(uint32_t when, Executable* execRef, TimerUnit
 	auto taskId = findFreeTask();
 	if (taskId != TASKMGR_INVALIDID) {
 	    auto task = getTask(taskId);
-		task->initialise(when, timeUnit, execRef, deleteWhenDone);
+		task->initialise(when, timeUnit, execRef, deleteWhenDone, false);
 		putItemIntoQueue(task);
 	}
 	return taskId;
@@ -131,7 +131,7 @@ taskid_t TaskManager::scheduleFixedRate(uint32_t when, Executable* execRef, Time
 	auto taskId = findFreeTask();
 	if (taskId != TASKMGR_INVALIDID) {
         auto task = getTask(taskId);
-        task->initialise(when, TimerUnit(timeUnit | TM_TIME_REPEATING), execRef, deleteWhenDone);
+        task->initialise(when, timeUnit, execRef, deleteWhenDone, true);
 		putItemIntoQueue(task);
 	}
 	return taskId;

src/TaskManager.h

@@ -8,6 +8,7 @@
 
 #include "TaskPlatformDeps.h"
 #include "TaskTypes.h"
+#include "TaskBlock.h"
 
 /** 
  * @file TaskManager.h
@@ -82,60 +83,6 @@ class BasicArduinoInterruptAbstraction : public InterruptAbstraction {
 };
 #endif // IOA_USE_ARDUINO - Arduino Only
 
-/**
- * This is an internal class, and users of the library generally don't see it.
- *
- * Task manager can never deallocate memory that it has already allocated for tasks, this is in order to make thread
- * safety much easier. Given this we allocate tasks in blocks of DEFAULT_TASK_SIZE and each tranche contains it's start
- * and end point in the "array". DEFAULT task size is set to 20 on 32 bit hardware where the size is negligible, 10
- * on MEGA2560 and all other AVR boards default to 6. We allow up to 8 tranches on AVR and up to 16 on 32 bit boards.
- * This should provide more than enough tasks for most boards.
- */
-class TaskBlock {
-private:
-    TimerTask tasks[DEFAULT_TASK_SIZE];
-    const taskid_t first;
-    const taskid_t arraySize;
-public:
-    explicit TaskBlock(taskid_t first_) : first(first_), arraySize(DEFAULT_TASK_SIZE) {}
-
-    /**
-     * Checks if taskId is contained within this block
-     * @param task the task ID to check
-     * @return true if contained, otherwise false
-     */
-    bool isTaskContained(taskid_t task) const {
-        return task >= first && task < (first + arraySize);
-    };
-
-    TimerTask* getContainedTask(taskid_t task) {
-        return isTaskContained(task) ? &tasks[task - first] : nullptr;
-    }
-
-    void clearAll() {
-        for(taskid_t i=0; i<arraySize;i++) {
-            tasks[i].clear();
-        }
-    }
-
-    taskid_t allocateTask() {
-        for(taskid_t i=0; i<arraySize; i++) {
-            if(tasks[i].allocateIfPossible()) {
-                return i + first;
-            }
-        }
-        return TASKMGR_INVALIDID;
-    }
-
-    taskid_t lastSlot() const {
-        return first + arraySize - 1;
-    }
-
-    taskid_t firstSlot() const {
-        return first;
-    }
-};
-
 /**
  * TaskManager is a lightweight cooperative co-routine implementation for Arduino, it works by scheduling tasks to be
  * done either immediately, or at a future point in time. It is quite efficient at scheduling tasks as internally tasks

src/TaskTypes.cpp

@@ -35,34 +35,34 @@ TimerTask::TimerTask() {
     tm_internal::atomicWriteBool(&taskInUse, false);
 }
 
-void TimerTask::initialise(sched_t execInfo, TimerUnit unit, TimerFn execCallback) {
-    this->myTimingSchedule = execInfo;
-    this->timingInformation = unit;
+void TimerTask::initialise(sched_t when, TimerUnit unit, TimerFn execCallback, bool repeating) {
+    handleScheduling(when, unit, repeating);
     this->callback = execCallback;
     this->executeMode = EXECTYPE_FUNCTION;
+}
 
-    this->scheduledAt = (isMicrosSchedule()) ? micros() : millis();
+void TimerTask::handleScheduling(sched_t when, TimerUnit unit, bool repeating) {
     tm_internal::atomicWritePtr(&next, nullptr);
+
+    if(unit == TIME_SECONDS) {
+        when = when * sched_t(1000);
+        unit = TIME_MILLIS;
+    }
+    this->myTimingSchedule = when;
+    this->timingInformation = repeating ? TimerUnit(unit | TM_TIME_REPEATING)  : unit;
+    this->scheduledAt = (isMicrosSchedule()) ? micros() : millis();
 }
 
-void TimerTask::initialise(uint32_t execInfo, TimerUnit unit, Executable* execCallback, bool deleteWhenDone) {
-    this->myTimingSchedule = execInfo;
-    this->timingInformation = unit;
+void TimerTask::initialise(uint32_t when, TimerUnit unit, Executable* execCallback, bool deleteWhenDone, bool repeating) {
+    handleScheduling(when, unit, repeating);
     this->taskRef = execCallback;
     this->executeMode = deleteWhenDone ? ExecutionType(EXECTYPE_EXECUTABLE | EXECTYPE_DELETE_ON_DONE) : EXECTYPE_EXECUTABLE;
-
-    this->scheduledAt = (isMicrosSchedule()) ? micros() : millis();
-    tm_internal::atomicWritePtr(&next, nullptr);
 }
 
 void TimerTask::initialiseEvent(BaseEvent* event, bool deleteWhenDone) {
-    this->timingInformation = (TimerUnit)(TIME_MICROS | TM_TIME_REPEATING);
-    this->myTimingSchedule = 0;
+    handleScheduling(0, TIME_MICROS, true);
     this->eventRef = event;
     this->executeMode = deleteWhenDone ? ExecutionType(EXECTYPE_EVENT | EXECTYPE_DELETE_ON_DONE) : EXECTYPE_EVENT;
-
-    this->scheduledAt = micros();
-    tm_internal::atomicWritePtr(&next, nullptr);
 }
 
 bool TimerTask::isReady() {
@@ -72,10 +72,6 @@ bool TimerTask::isReady() {
         uint32_t delay = myTimingSchedule;
         return (micros() - scheduledAt) >= delay;
     }
-    else if(isSecondsSchedule()) {
-        uint32_t delay = uint32_t(myTimingSchedule) * 1000UL;
-        return (millis() - scheduledAt) >= delay;
-    }
     else {
         uint32_t delay = myTimingSchedule;
         return (millis() - scheduledAt) >= delay;
@@ -91,9 +87,6 @@ unsigned long TimerTask::microsFromNow() {
     }
     else {
         uint32_t delay = myTimingSchedule;
-        if (isSecondsSchedule()) {
-            delay *= 1000UL;
-        }
         uint32_t alreadyTaken = (millis() - scheduledAt);
         microsFromNow = (delay < alreadyTaken) ? 0 : ((delay - alreadyTaken) * 1000UL);
     }

src/TaskTypes.h

@@ -133,7 +133,6 @@ enum TimerUnit : uint8_t {
     TM_TIME_RUNNING = 0x20,
 
     TIME_REP_MICROS = TIME_MICROS | TM_TIME_REPEATING,
-    TIME_REP_SECONDS = TIME_SECONDS | TM_TIME_REPEATING,
     TIME_REP_MILLIS = TIME_MILLIS | TM_TIME_REPEATING,
 };
 
@@ -204,7 +203,7 @@ class TimerTask {
      * @param unit the unit of time measurement
      * @param execCallback the function to call back
      */
-    void initialise(sched_t executionInfo, TimerUnit unit, TimerFn execCallback);
+    void initialise(sched_t when, TimerUnit unit, TimerFn execCallback, bool repeating);
 
     /**
      * Initialise a task slot with execution information
@@ -213,7 +212,7 @@ class TimerTask {
      * @param executable the class instance to call back
      * @param deleteWhenDone indicates taskmanager owns this memory and should delete it when clear is called.
      */
-    void initialise(sched_t executionInfo, TimerUnit unit, Executable *executable, bool deleteWhenDone);
+    void initialise(sched_t when, TimerUnit unit, Executable *executable, bool deleteWhenDone, bool repeating);
 
     /**
      * Initialise an event structure, which will call the event immediately to get the next poll time
@@ -222,6 +221,13 @@ class TimerTask {
      */
     void initialiseEvent(BaseEvent *event, bool deleteWhenDone);
 
+    /**
+     * Called by all the initialise methods to actually do the initial scheduling.
+     * @param when when the task is to take place.
+     * @param unit the time unit upon which it will occur.
+     */
+    void handleScheduling(sched_t when, TimerUnit unit, bool repeating);
+
     /**
      * Atomically checks if the task is in use at the moment.
      * @return true if in use, otherwise false.
@@ -305,9 +311,14 @@ class TimerTask {
      */
     void processEvent();
 
+    /**
+     * @return true if the task is on a microsecond schedule
+     */
     bool isMicrosSchedule()  { return (timingInformation & 0x0fU)==TIME_MICROS; }
+    /**
+     * @return true if the task in on a millisecond schedule
+     */
     bool isMillisSchedule()  { return (timingInformation & 0x0fU)==TIME_MILLIS; }
-    bool isSecondsSchedule()  { return (timingInformation & 0x0fU)==TIME_SECONDS; }
 };
 
 #endif //TASKMANAGER_IO_TASKTYPES_H

tests/taskMgrTests/ESPMultiThreadedTest.cpp

@@ -0,0 +1,62 @@
+#ifdef ESP32
+
+#include <AUnit.h>
+#include <TaskManagerIO.h>
+#include "test_utils.h"
+#include <pthread.h>
+
+using namespace aunit;
+
+int executions = 0;
+int failedCreations = 0;
+
+void callbackFunction() {
+    executions++;
+}
+
+void* creationThread(void* param) {
+    Serial.println("Start thread to create tasks");
+
+    for(int i = 0; i < 500; i++) {
+        if(TASKMGR_INVALIDID == taskManager.execute(callbackFunction)) failedCreations++;
+        delay(5);
+    }
+
+    Serial.println("Completed task creation");
+}
+
+void* scheduledCreationThread(void* param) {
+    Serial.println("Start thread to schedule tasks");
+
+    for(int i = 0; i < 250; i++) {
+        if(TASKMGR_INVALIDID == taskManager.scheduleOnce(15, callbackFunction)) failedCreations++;
+        delay(10);
+    }
+
+    Serial.println("Completed scheduled task creation");
+}
+
+/**
+ * when I create a lot of tasks over three threads that are either immediate executed or near immediately executed
+ * then they should all be scheduled and there should be no failures
+ */
+test(multiThreadedTestForESP) {
+    pthread_t threadId1;
+    pthread_t threadId2;
+    pthread_t threadId3;
+    pthread_create(&threadId1, NULL, creationThread, (void*)1);
+    pthread_create(&threadId2, NULL, creationThread, (void*)2);
+    pthread_create(&threadId3, NULL, scheduledCreationThread, (void*)3);
+
+    unsigned long startTime = millis();
+
+    // wait until the task is marked as scheduled.
+    while(executions < 2000 && (millis() - startTime) < 5000) {
+        taskManager.yieldForMicros(10000);
+    }
+
+    assertEqual(1250, executions);
+    assertEqual(0, failedCreations);
+}
+
+#endif