From 9e883d793fed23dadec29bd83e2873befa9c9715 Mon Sep 17 00:00:00 2001
From: Sukrit Kalra <sukritkalra@gmail.com>
Date: Wed, 1 Nov 2023 03:26:33 -0700
Subject: [PATCH] Fix bugs in TetriSched scheduler.

---
 schedulers/tetrisched/src/Expression.cpp |  66 +++--
 schedulers/tetrisched_scheduler.py       | 294 ++++++++++++++++-------
 simulator.py                             |  30 ++-
 3 files changed, 279 insertions(+), 111 deletions(-)

diff --git a/schedulers/tetrisched/src/Expression.cpp b/schedulers/tetrisched/src/Expression.cpp
index 522be0f7..795beb1f 100644
--- a/schedulers/tetrisched/src/Expression.cpp
+++ b/schedulers/tetrisched/src/Expression.cpp
@@ -1,10 +1,10 @@
 #include "tetrisched/Expression.hpp"
 
 #include <algorithm>
-#include <limits>
 #include <boost/uuid/uuid.hpp>
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/uuid/uuid_io.hpp>
+#include <limits>
 #include <stack>
 
 /// A method to generate a UUID for different classes.
@@ -95,7 +95,7 @@ void CapacityConstraintMap::registerUsageForDuration(
     const Partition& partition, Time startTime, Time duration,
     VariablePtr variable, std::optional<Time> granularity) {
   Time _granularity = granularity.value_or(this->granularity);
-  for (Time time = startTime; time < startTime + duration;
+  for (Time time = startTime; time <= startTime + duration;
        time += _granularity) {
     registerUsageAtTime(partition, time, variable);
   }
@@ -105,7 +105,7 @@ void CapacityConstraintMap::registerUsageForDuration(
     const Partition& partition, Time startTime, Time duration, uint32_t usage,
     std::optional<Time> granularity) {
   Time _granularity = granularity.value_or(this->granularity);
-  for (Time time = startTime; time < startTime + duration;
+  for (Time time = startTime; time <= startTime + duration;
        time += _granularity) {
     registerUsageAtTime(partition, time, usage);
   }
@@ -147,6 +147,10 @@ size_t Expression::getNumChildren() const { return children.size(); }
 std::vector<ExpressionPtr> Expression::getChildren() const { return children; }
 
 void Expression::addChild(ExpressionPtr child) {
+  if (child == nullptr) {
+    throw tetrisched::exceptions::ExpressionConstructionException(
+        "Cannot add a null child to the Expression " + name + ".");
+  }
   child->addParent(shared_from_this());
   children.push_back(child);
 }
@@ -189,6 +193,8 @@ std::vector<ExpressionPtr> Expression::getParents() const {
 }
 
 SolutionResultPtr Expression::populateResults(SolverModelPtr solverModel) {
+  TETRISCHED_DEBUG("Populating results for " << name << " of type "
+                                             << getTypeString() << ".")
   // Check that the Expression was parsed before.
   if (!parsedResult) {
     throw tetrisched::exceptions::ExpressionSolutionException(
@@ -209,9 +215,13 @@ SolutionResultPtr Expression::populateResults(SolverModelPtr solverModel) {
   solution = std::make_shared<SolutionResult>();
   switch (parsedResult->type) {
     case ParseResultType::EXPRESSION_PRUNE:
+      TETRISCHED_DEBUG("Pruning Expression " << name << " of type "
+                                             << getTypeString() << ".")
       solution->type = SolutionResultType::EXPRESSION_PRUNE;
       return solution;
     case ParseResultType::EXPRESSION_NO_UTILITY:
+      TETRISCHED_DEBUG("Expression " << name << " of type " << getTypeString()
+                                     << " had no utility to maximize.")
       solution->type = SolutionResultType::EXPRESSION_NO_UTILITY;
       return solution;
     case ParseResultType::EXPRESSION_UTILITY:
@@ -257,18 +267,27 @@ SolutionResultPtr Expression::populateResults(SolverModelPtr solverModel) {
   // Our default way of populating the placements is to retrieve the
   // children's placements and coalesce them into a single Placements map.
   for (auto& childExpression : children) {
-    auto childExpressionSolution = childExpression->getSolution().value();
-    if (childExpressionSolution->utility == 0) {
+    auto childExpressionSolution = childExpression->getSolution();
+    if (!childExpressionSolution.has_value()) {
+      throw tetrisched::exceptions::ExpressionSolutionException(
+          "Expression " + name +
+          " with a utility was parsed without a solution for child " +
+          childExpression->getName() + ".");
+    }
+    if (childExpressionSolution.value()->utility == 0) {
       // This child was not satisfied. Skip it.
       continue;
     }
 
     // The child was satisfied, merge its Placement objects with our own.
-    for (auto& [taskName, placement] : childExpressionSolution->placements) {
+    for (auto& [taskName, placement] :
+         childExpressionSolution.value()->placements) {
       solution->placements[taskName] = placement;
     }
   }
 
+  TETRISCHED_DEBUG("Finished populating results for " << name << " of type "
+                                                      << getTypeString() << ".")
   return solution;
 }
 
@@ -328,8 +347,7 @@ std::string Expression::getDescriptiveName() const {
 ChooseExpression::ChooseExpression(std::string taskName,
                                    Partitions resourcePartitions,
                                    uint32_t numRequiredMachines, Time startTime,
-                                   Time duration,
-                                   TETRISCHED_ILP_TYPE utility)
+                                   Time duration, TETRISCHED_ILP_TYPE utility)
     : Expression(taskName, ExpressionType::EXPR_CHOOSE),
       resourcePartitions(resourcePartitions),
       numRequiredMachines(numRequiredMachines),
@@ -487,7 +505,7 @@ MalleableChooseExpression::MalleableChooseExpression(
       startTime(startTime),
       endTime(endTime),
       granularity(granularity),
-      partitionVariables(), 
+      partitionVariables(),
       utility(utility) {}
 
 void MalleableChooseExpression::addChild(ExpressionPtr child) {
@@ -946,21 +964,37 @@ SolutionResultPtr ObjectiveExpression::populateResults(
   Time minStartTime = std::numeric_limits<Time>::max();
   Time maxEndTime = std::numeric_limits<Time>::min();
   for (auto& childExpression : children) {
-    auto childExpressionSolution = childExpression->getSolution().value();
+    auto childExpressionSolution = childExpression->getSolution();
+    if (!childExpressionSolution.has_value()) {
+      throw tetrisched::exceptions::ExpressionSolutionException(
+          "ObjectiveExpression " + name + "'s child " +
+          childExpression->getName() + " does not have a solution.");
+    }
+
+    auto childExpressionSolutionValue = childExpressionSolution.value();
 
     // If the child expression was not satisfied, skip it.
-    if (childExpressionSolution->utility == 0) {
+    if (childExpressionSolutionValue->type !=
+            ParseResultType::EXPRESSION_UTILITY ||
+        childExpressionSolutionValue->utility == 0) {
       continue;
     }
 
+    if (!childExpressionSolutionValue->startTime.has_value() ||
+        !childExpressionSolutionValue->endTime.has_value()) {
+      throw tetrisched::exceptions::ExpressionSolutionException(
+          "ObjectiveExpression " + name + "'s child " +
+          childExpression->getName() + " does not have a start or end time.");
+    }
+
     // If the child has a smaller start time, use it.
-    if (childExpressionSolution->startTime.value() < minStartTime) {
-      minStartTime = childExpressionSolution->startTime.value();
+    if (childExpressionSolutionValue->startTime.value() < minStartTime) {
+      minStartTime = childExpressionSolution.value()->startTime.value();
     }
 
     // If the child has a larger end time, use it.
-    if (childExpressionSolution->endTime.value() > maxEndTime) {
-      maxEndTime = childExpressionSolution->endTime.value();
+    if (childExpressionSolutionValue->endTime.value() > maxEndTime) {
+      maxEndTime = childExpressionSolution.value()->endTime.value();
     }
   }
 
@@ -1033,7 +1067,7 @@ ParseResultPtr LessThanExpression::parse(
     auto secondChildStartTime =
         static_cast<int64_t>(secondChildResult->startTime->get<Time>());
 
-    if (firstChildEndTime - secondChildStartTime <= 1) {
+    if (firstChildEndTime <= secondChildStartTime - 1) {
       // This clause is trivially satisfied, populate the results.
       parsedResult->type = ParseResultType::EXPRESSION_UTILITY;
       parsedResult->startTime.emplace(firstChildResult->startTime.value());
diff --git a/schedulers/tetrisched_scheduler.py b/schedulers/tetrisched_scheduler.py
index 3763cedd..4dd8136d 100644
--- a/schedulers/tetrisched_scheduler.py
+++ b/schedulers/tetrisched_scheduler.py
@@ -1,8 +1,8 @@
 import time
 from typing import List, Mapping, Optional, Set
 
-import absl # noqa: F401
-import numpy as np 
+import absl  # noqa: F401
+import numpy as np
 import tetrisched_py as tetrisched
 
 from schedulers import BaseScheduler
@@ -78,6 +78,7 @@ def schedule(
             branch_prediction_accuracy=self.branch_prediction_accuracy,
             release_taskgraphs=self.release_taskgraphs,
         )
+
         task_description_string = [
             f"{t.unique_name} ("
             f"{t.available_execution_strategies.get_fastest_strategy().runtime}, "
@@ -87,15 +88,6 @@ def schedule(
         task_graph_names: Set[TaskGraph] = {
             task.task_graph for task in tasks_to_be_scheduled
         }
-        # for task_graph_name in task_graph_names:
-        #     task_graph = workload.get_task_graph(task_graph_name)
-        #     print(
-        #         "The TaskGraph {} has {} completion time and {} deadline".format(
-        #             task_graph_name,
-        #             task_graph.job_graph.completion_time,
-        #             task_graph.deadline,
-        #         )
-        #     )
         self._logger.debug(
             f"[{sim_time.time}] The scheduler received {len(tasks_to_be_scheduled)} "
             f"tasks to be scheduled from {len(task_graph_names)} TaskGraphs. "
@@ -103,6 +95,26 @@ def schedule(
             f"(runtimes, deadlines) were: {task_description_string}."
         )
 
+        # Find the currently running and scheduled tasks to inform
+        # the scheduler of previous placements.
+        if self.retract_schedules:
+            # If we are retracting schedules, the scheduler will re-place
+            # the scheduled tasks, so we should only consider RUNNING tasks.
+            filter_fn = lambda task: task.state == TaskState.RUNNING  # noqa: E731
+        else:
+            # If we are not retracting schedules, we should consider both
+            # RUNNING and SCHEDULED task placements as permanent.
+            filter_fn = lambda task: task.state in (  # noqa: E731
+                TaskState.RUNNING,
+                TaskState.SCHEDULED,
+            )
+        previously_placed_tasks = workload.filter(filter_fn)
+        self._logger.debug(
+            f"[{sim_time.time}] The scheduler is also considering the following "
+            f"{len(previously_placed_tasks)} for their effects on the current "
+            f"placements: {[task.unique_name for task in previously_placed_tasks]}."
+        )
+
         # Construct the STRL expression.
         scheduler_start_time = time.time()
         placements = []
@@ -112,11 +124,21 @@ def schedule(
             # Construct the partitions from the Workers in the WorkerPool.
             partitions = self.construct_partitions(worker_pools=worker_pools)
 
-            # Construct the STRL expressions for each TaskGraph and add them together
-            # in a single objective expression.
+            # Construct the ObjectiveExpression to be optimized.
             objective_strl = tetrisched.strl.ObjectiveExpression(
                 f"TetriSched_{sim_time.to(EventTime.Unit.US).time}"
             )
+
+            # For the tasks that have been previously placed, add an
+            # AllocationExpression for their current allocations so as to correctly
+            # account for capacities at each time discretization.
+            for task in previously_placed_tasks:
+                task_strl = self.construct_task_strl(sim_time, task, partitions)
+                if task_strl is not None:
+                    objective_strl.addChild(task_strl)
+
+            # Construct the STRL expressions for each TaskGraph and add them together
+            # in a single objective expression.
             for task_graph_name in task_graph_names:
                 # Retrieve the TaskGraph and construct its STRL.
                 task_graph = workload.get_task_graph(task_graph_name)
@@ -124,7 +146,6 @@ def schedule(
                     current_time=sim_time,
                     task_graph=task_graph,
                     partitions=partitions,
-                    task_strls={},
                     tasks_to_be_scheduled=tasks_to_be_scheduled,
                 )
                 if task_graph_strl is not None:
@@ -143,8 +164,10 @@ def schedule(
                 self._logger.error(
                     f'[{sim_time.time}] Received error with description: "{e}" '
                     f"while invoking the STRL-based Scheduler. Dumping the model to "
-                    f"tetrisched_error_{sim_time.time}.lp."
+                    f"tetrisched_error_{sim_time.time}.lp and STRL expression to "
+                    f"tetrisched_error_{sim_time.time}.dot."
                 )
+                objective_strl.exportToDot(f"tetrisched_error_{sim_time.time}.dot")
                 self._scheduler.exportLastSolverModel(
                     f"tetrisched_error_{sim_time.time}.lp"
                 )
@@ -153,9 +176,11 @@ def schedule(
             # If requested, log the model to a file.
             if self._log_to_file or sim_time.time in self._log_times:
                 self._scheduler.exportLastSolverModel(f"tetrisched_{sim_time.time}.lp")
+                objective_strl.exportToDot(f"tetrisched_{sim_time.time}.dot")
                 self._logger.debug(
                     f"[{sim_time.to(EventTime.Unit.US).time}] Exported model to "
-                    f"tetrisched_{sim_time.time}.lp."
+                    f"tetrisched_{sim_time.time}.lp and STRL to "
+                    f"tetrisched_{sim_time.time}.dot"
                 )
 
             # Retrieve the solution and check if we were able to schedule anything.
@@ -165,49 +190,58 @@ def schedule(
                 f" and took {solver_time} to solve. The solution result "
                 f"was {self._scheduler.getLastSolverSolution()}."
             )
-            if solverSolution.utility == 0:
-                raise RuntimeError(
-                    f"TetrischedScheduler was unable to schedule tasks at {sim_time}."
-                )
-
-            # Retrieve the Placements for each task.
-            for task in tasks_to_be_scheduled:
-                task_placement = solverSolution.getPlacement(task.unique_name)
-                if task_placement is None or not task_placement.isPlaced():
-                    self._logger.error(
-                        f"[{sim_time.time}] No Placement was found for "
-                        f"Task {task.unique_name}."
+            if solverSolution.utility > 0:
+                # Retrieve the Placements for each task.
+                for task in tasks_to_be_scheduled:
+                    task_placement = solverSolution.getPlacement(task.unique_name)
+                    if task_placement is None or not task_placement.isPlaced():
+                        self._logger.error(
+                            f"[{sim_time.time}] No Placement was found for "
+                            f"Task {task.unique_name}."
+                        )
+                        placements.append(Placement.create_task_placement(task=task))
+                        continue
+
+                    # Retrieve the Partition where the task was placed.
+                    # The task was placed, retrieve the Partition where the task
+                    # was placed.
+                    partitionAllocations = task_placement.getPartitionAllocations()
+                    partitionId = list(partitionAllocations.keys())[0]
+                    partition = partitions.partitionMap[partitionId]
+                    task_placement = Placement.create_task_placement(
+                        task=task,
+                        placement_time=EventTime(
+                            task_placement.startTime, EventTime.Unit.US
+                        ),
+                        worker_id=partition.associatedWorker.id,
+                        worker_pool_id=partition.associatedWorkerPool.id,
+                        execution_strategy=task.available_execution_strategies[0],
                     )
-                    placements.append(Placement.create_task_placement(task=task))
-                    continue
-
-                # Retrieve the Partition where the task was placed.
-                # The task was placed, retrieve the Partition where the task
-                # was placed.
-                partitionAllocations = task_placement.getPartitionAllocations()
-                partitionId = list(partitionAllocations.keys())[0]
-                partition = partitions.partitionMap[partitionId]
-                task_placement = Placement.create_task_placement(
-                    task=task,
-                    placement_time=EventTime(
-                        task_placement.startTime, EventTime.Unit.US
-                    ),
-                    worker_id=partition.associatedWorker.id,
-                    worker_pool_id=partition.associatedWorkerPool.id,
-                    execution_strategy=task.available_execution_strategies[0],
-                )
-                placements.append(task_placement)
-                self._logger.debug(
-                    "[%s] Placed %s (with deadline %s and remaining time %s) on "
-                    "WorkerPool (%s) to be started at %s and executed with %s.",
-                    sim_time.to(EventTime.Unit.US).time,
-                    task_placement.task.unique_name,
-                    task_placement.task.deadline,
-                    task_placement.execution_strategy.runtime,
-                    task_placement.worker_pool_id,
-                    task_placement.placement_time,
-                    task_placement.execution_strategy,
-                )
+                    placements.append(task_placement)
+                    self._logger.debug(
+                        "[%s] Placed %s (with deadline %s and remaining time %s) on "
+                        "WorkerPool (%s) to be started at %s and executed with %s.",
+                        sim_time.to(EventTime.Unit.US).time,
+                        task_placement.task.unique_name,
+                        task_placement.task.deadline,
+                        task_placement.execution_strategy.runtime,
+                        task_placement.worker_pool_id,
+                        task_placement.placement_time,
+                        task_placement.execution_strategy,
+                    )
+            else:
+                # There were no Placements from the Scheduler. Inform the Simulator.
+                for task in tasks_to_be_scheduled:
+                    placements.append(
+                        Placement.create_task_placement(
+                            task=task,
+                            placement_time=None,
+                            worker_pool_id=None,
+                            worker_id=None,
+                            execution_strategy=None,
+                        )
+                    )
+                self._logger.warning(f"[{sim_time.time}] Failed to place any tasks.")
 
         scheduler_end_time = time.time()
         scheduler_runtime = EventTime(
@@ -329,17 +363,100 @@ def construct_task_strl(
                     "TetrischedScheduler currently only supports Slot resources."
                 )
 
-        # Construct the STRL ChooseExpressions for this Task.
-        # This expression represents a particular placement choice for this Task.
+        # Find the number of slots required to execute this Task.
         num_slots_required = execution_strategy.resources.get_total_quantity(
             resource=Resource(name="Slot", _id="any")
         )
 
+        # Compute the remaining time.
+        task_remaining_time = (
+            task.remaining_time
+            if task.state == TaskState.RUNNING
+            else execution_strategy.runtime
+        )
+
+        # Compute the time discretizations for this Task.
         time_discretizations = self._get_time_discretizations_until(
-            current_time, task.deadline - execution_strategy.runtime
+            current_time, task.deadline - task_remaining_time
         )
+        if len(time_discretizations) == 0:
+            self._logger.warn(
+                f"[{current_time.time}] No time discretizations were feasible for "
+                f"{task.unique_name} from range {current_time} to "
+                f"{task.deadline - task_remaining_time}."
+            )
+            return None
+
+        # If the task is already running or scheduled and we're not reconsidering
+        # previous schedulings, we block off all the time discretizations from the
+        # task's start until it completes.
+        if task.state == TaskState.RUNNING or (
+            task.state == TaskState.SCHEDULED and not self.retract_schedules
+        ):
+            # Find the Partition where the task is running or to be scheduled.
+            scheduled_partition = None
+            for partition in partitions.partitionMap.values():
+                if partition.associatedWorker.id == task.current_placement.worker_id:
+                    scheduled_partition = partition
+                    break
+
+            if scheduled_partition is None:
+                raise ValueError(
+                    f"Could not find the Partition for the Task "
+                    f"{task.unique_name} in state {task.state}."
+                )
 
-        time_range = [time_discretization.time for time_discretization in time_discretizations]
+            # Find the discretization where the Task is running or to be scheduled.
+            scheduled_discretization = None
+            if task.state == TaskState.RUNNING:
+                scheduled_discretization = time_discretizations[0]
+                # BUG (Sukrit): If we go back in time and set the discretization from
+                # the past, then we need to correctly account for the remaining time
+                # from that point, instead of the current.
+                task_remaining_time = (
+                    current_time - scheduled_discretization
+                ) + task_remaining_time
+            else:
+                for index, time_discretization in enumerate(time_discretizations):
+                    if (
+                        time_discretization <= task.current_placement.placement_time
+                        and (
+                            index == len(time_discretizations) - 1
+                            or time_discretizations[index + 1]
+                            > task.current_placement.placement_time
+                        )
+                    ):
+                        # This is the first discretization where we should be blocking.
+                        scheduled_discretization = time_discretization
+                        break
+
+            if scheduled_discretization is None:
+                raise ValueError(
+                    f"Could not find the discretization for the Task "
+                    f"{task.unique_name} in state {task.state} starting at "
+                    f"{task.current_placement.placement_time} from "
+                    f"{', '.join([str(t) for t in time_discretizations])}."
+                )
+
+            # Block off all the time discretizations from the task's start until it
+            # completes.
+            task_allocation_expression = tetrisched.strl.AllocationExpression(
+                task.unique_name,
+                [(scheduled_partition, num_slots_required)],
+                scheduled_discretization.to(EventTime.Unit.US).time,
+                task_remaining_time.to(EventTime.Unit.US).time,
+            )
+            self._logger.debug(
+                f"[{current_time.time}] Generated an AllocationExpression for "
+                f"task {task.unique_name} in state {task.state} starting at "
+                f"{scheduled_discretization} and running for {task.remaining_time} "
+                f"on Partition {scheduled_partition.id}."
+            )
+            return task_allocation_expression
+
+        time_range = [
+            time_discretization.time for time_discretization in time_discretizations
+        ]
         # The placement reward skews the reward towards placing the task earlier.
         # We interpolate the time range to a range between 2 and 1 and use that to
         # skew the reward towards earlier placement.
@@ -376,28 +493,34 @@ def construct_task_strl(
                 f"{task.unique_name} with deadline {task.deadline}."
             )
             return None
+        elif len(task_choose_expressions) == 1:
+            self._logger.debug(
+                f"[{current_time.time}] Generated a single ChooseExpression for "
+                f"{task.unique_name} with deadline {task.deadline}."
+            )
+            return task_choose_expressions[0]
+        else:
+            self._logger.debug(
+                f"[{current_time.time}] Generated {len(task_choose_expressions)} "
+                f"ChooseExpressions for {task.unique_name} for times "
+                f"{[str(t) for t in time_discretizations]} for {num_slots_required} "
+                f"slots for {execution_strategy.runtime}."
+            )
 
-        self._logger.debug(
-            f"[{current_time.time}] Generated {len(task_choose_expressions)} "
-            f"ChooseExpressions for {task.unique_name} for times "
-            f"{[str(t) for t in time_discretizations]} for {num_slots_required} slots "
-            f"for {execution_strategy.runtime}."
-        )
-
-        # Construct the STRL MAX expression for this Task.
-        # This enforces the choice of only one placement for this Task.
-        self._logger.debug(
-            f"[{current_time.time}] Constructing a STRL expression tree for "
-            f"{task.name} (runtime={execution_strategy.runtime}, "
-            f"deadline={task.deadline}) with name: {task.unique_name}_placement."
-        )
-        chooseOneFromSet = tetrisched.strl.MaxExpression(
-            f"{task.unique_name}_placement"
-        )
-        for choose_expression in task_choose_expressions:
-            chooseOneFromSet.addChild(choose_expression)
+            # Construct the STRL MAX expression for this Task.
+            # This enforces the choice of only one placement for this Task.
+            self._logger.debug(
+                f"[{current_time.time}] Constructing a STRL expression tree for "
+                f"{task.name} (runtime={execution_strategy.runtime}, "
+                f"deadline={task.deadline}) with name: {task.unique_name}_placement."
+            )
+            chooseOneFromSet = tetrisched.strl.MaxExpression(
+                f"{task.unique_name}_placement"
+            )
+            for choose_expression in task_choose_expressions:
+                chooseOneFromSet.addChild(choose_expression)
 
-        return chooseOneFromSet
+            return chooseOneFromSet
 
     def _construct_task_graph_strl(
         self,
@@ -512,7 +635,6 @@ def construct_task_graph_strl(
         current_time: EventTime,
         task_graph: TaskGraph,
         partitions: tetrisched.Partitions,
-        task_strls: Optional[Mapping[str, tetrisched.strl.Expression]] = None,
         tasks_to_be_scheduled: Optional[List[Task]] = None,
     ) -> tetrisched.strl.Expression:
         """Constructs the STRL expression subtree for a given TaskGraph.
@@ -530,7 +652,7 @@ def construct_task_graph_strl(
         """
         # Maintain a cache to be used across the construction of the TaskGraph to make
         # it DAG-aware.
-        task_strls = task_strls if task_strls else {}
+        task_strls = {}
 
         # Construct the STRL expression for all the roots of the TaskGraph.
         root_task_strls = []
@@ -570,3 +692,7 @@ def construct_task_graph_strl(
             for root_task_strl in root_task_strls:
                 min_expression_task_graph.addChild(root_task_strl)
             return min_expression_task_graph
+            return min_expression_task_graph
+            return min_expression_task_graph
+            return min_expression_task_graph
+            return min_expression_task_graph
diff --git a/simulator.py b/simulator.py
index f8088018..714e4af8 100644
--- a/simulator.py
+++ b/simulator.py
@@ -794,16 +794,24 @@ def __create_events_from_task_placement(
                 "Rescheduling of PREEMPTED tasks hasn't been implemented yet."
             )
         else:
-            # Task was either completed or cancelled before the Scheduler finished,
-            # we skip the application of this Placement decision.
-            self._logger.warning(
-                "[%s] Skipping the application of Placement of Task %s at "
-                "time %s because the Task was in %s state.",
-                event_time.to(EventTime.Unit.US).time,
-                placement.task,
-                placement.placement_time,
-                placement.task.state,
-            )
+            if not placement.is_placed():
+                self._logger.debug(
+                    "[%s] The Task %s was cancelled by an upstream task, "
+                    "skipping its re-cancellation.",
+                    event_time.to(EventTime.Unit.US).time,
+                    placement.task,
+                )
+            else:
+                # Task was either completed or cancelled before the Scheduler finished,
+                # we skip the application of this Placement decision.
+                self._logger.warning(
+                    "[%s] Skipping the application of Placement of Task %s at "
+                    "time %s because the Task was in %s state.",
+                    event_time.to(EventTime.Unit.US).time,
+                    placement.task,
+                    placement.placement_time,
+                    placement.task.state,
+                )
 
         return simulator_events
 
@@ -1712,7 +1720,7 @@ def __get_next_scheduler_event(
             adjusted_scheduler_start_time = max(scheduler_start_time, next_event_time)
 
             if scheduler_start_time != adjusted_scheduler_start_time:
-                self._logger.warning(
+                self._logger.info(
                     "[%s] The scheduler start time was pushed from %s to %s since "
                     "either the next running task finishes at %s or the next "
                     "TASK_RELEASE event is being invoked at %s.",