Refactoring scheduler to new params strategy

Author: Jens Hahne

blockops/iteration.py

@@ -12,9 +12,9 @@
 from blockops.block import BlockOperator, I
 from blockops.run import PintRun
 from blockops.taskPool import TaskPool
-from blockops.schedule import getSchedule
 from blockops.utils.expr import getCoeffsFromFormula
 from blockops.graph import PintGraph
+from blockops.scheduler import getSchedule
 
 
 # -----------------------------------------------------------------------------
@@ -202,36 +202,36 @@ def __call__(self, nIter, nBlocks=None, u0=None, initSol=False, predSol=None):
         else:
             return u[:, 1:]
 
-    def getRuntime(self, N, K, nProc, schedule_type='BLOCK-BY-BLOCK'):
+    def getRuntime(self, N, K, nProc, schedulerType='BLOCK-BY-BLOCK'):
         K = self.checkK(N=N, K=K)
         run = PintRun(blockIteration=self, nBlocks=N, kMax=K)
         pool = TaskPool(run=run)
-        schedule = getSchedule(taskPool=pool, nProc=nProc, nPoints=N + 1, schedule_type=schedule_type)
+        schedule = getSchedule(taskPool=pool, nProc=nProc, nPoints=N + 1, schedulerType=schedulerType)
         return schedule.getRuntime()
 
-    def getPerformances(self, N, K, nProc=None, schedule_type='BLOCK-BY-BLOCK', verbose=False):
+    def getPerformances(self, N, K, nProc=None, schedulerType='BLOCK-BY-BLOCK', verbose=False):
 
         seqPropCost = self.propagator.cost
         if (seqPropCost is None) or (seqPropCost == 0):
             raise ValueError(
                 'no cost given for fine propagator,'
                 ' cannot measure performances')
-        runtime_ts = seqPropCost * N
+        runtimeTs = seqPropCost * N
 
         K = self.checkK(N=N, K=K)
-        print(f' -- computing {schedule_type} cost for K={K}')
+        print(f' -- computing {schedulerType} cost for K={K}')
 
         run = PintRun(blockIteration=self, nBlocks=N, kMax=K)
         pool = TaskPool(run=run)
         schedule = getSchedule(
             taskPool=pool, nProc=nProc, nPoints=N + 1,
-            schedule_type=schedule_type)
+            schedulerType=schedulerType)
         runtime = schedule.getRuntime()
         nProc = schedule.nProc
 
         if verbose:
             graph = PintGraph(N, max(K), pool)
-            optimal_runtime = graph.longestPath()
+            optimalRuntime = graph.longestPath()
             print('=============================')
             if self.name is None:
                 print(f'Block iteration: {self.update}')
@@ -241,14 +241,14 @@ def getPerformances(self, N, K, nProc=None, schedule_type='BLOCK-BY-BLOCK', verb
             print(f'Predictor: {self.predictor}')
             print(f'N={N}, K={K} \n')
             print(f'Runtime of schedule={schedule.NAME} for nProc={nProc}: {runtime}')
-            print(f'Runtime time-stepping: {runtime_ts} (This is currently not the correct value)')
-            print(f'Speedup of schedule={schedule.NAME} for nProc={nProc}: {(runtime_ts / runtime):.2f} \n')
-            print(f'Theoretical lower runtime bound: {optimal_runtime}')
+            print(f'Runtime time-stepping: {runtimeTs} (This is currently not the correct value)')
+            print(f'Speedup of schedule={schedule.NAME} for nProc={nProc}: {(runtimeTs / runtime):.2f} \n')
+            print(f'Theoretical lower runtime bound: {optimalRuntime}')
             print(
-                f'Theoretical maximum speedup compared to time stepping: {(runtime_ts / optimal_runtime):.2f} (This is currently not the correct value)')
+                f'Theoretical maximum speedup compared to time stepping: {(runtimeTs / optimalRuntime):.2f} (This is currently not the correct value)')
             print('=============================')
 
-        speedup = runtime_ts / runtime
+        speedup = runtimeTs / runtime
         efficiency = speedup / nProc
         return speedup, efficiency, nProc
 
@@ -261,12 +261,12 @@ def plotGraph(self, N: int, K, figSize: tuple = (6.4, 4.8), saveFig: str = ""):
                             figSize=figSize, saveFig=saveFig)
         return run, pool, pintGraph
 
-    def plotSchedule(self, N: int, K, nProc: int, schedule_type: str = 'BLOCK-BY-BLOCK', figSize: tuple = (8, 4.8),
+    def plotSchedule(self, N: int, K, nProc: int, schedulerType: str = 'BLOCK-BY-BLOCK', figSize: tuple = (8, 4.8),
                      saveFig: str = ""):
         K = self.checkK(N=N, K=K)
         run = PintRun(blockIteration=self, nBlocks=N, kMax=K)
         pool = TaskPool(run=run)
-        schedule = getSchedule(taskPool=pool, nProc=nProc, nPoints=N + 1, schedule_type=schedule_type)
+        schedule = getSchedule(taskPool=pool, nProc=nProc, nPoints=N + 1, schedulerType=schedulerType)
         schedule.plot(figName=None if self.name is None else self.name + f' ({schedule.NAME} schedule)',
                       figSize=figSize, saveFig=saveFig)
 

blockops/run.py

@@ -239,6 +239,9 @@ def createExpressions(self):
                     self.blockRules[(n + 1, k + 1)] = {'result': res, 'rule': rule}
 
     def factorizeBlockRules(self) -> None:
+        """
+        Factorizes the block rules and saves everything in a dictionary
+        """
         for key, value in self.blockRules.items():
             self.facBlockRules[key] = {'rule': self.factorize(rule=value['rule'], res=value['result']),
                                        'result': value['result']
@@ -254,10 +257,11 @@ def factorize(self, rule, res: sy.Symbol) -> dict:
             The rule to compute the block iteration for n and k
         res : sy.Symbol
             The name of the result
-        n : int
-            Current block
-        k : int
-            Current iteration
+
+        Returns
+        -------
+        ruleDict : dict
+            Dictionary representing factorized expression
         """
 
         # If rule is just a copy of another task

blockops/scheduler/__init__.py

@@ -0,0 +1,192 @@
+import pkgutil
+import numpy as np
+from typing import Dict
+from matplotlib.lines import Line2D
+import matplotlib.pyplot as plt
+from matplotlib.patches import Rectangle
+from abc import ABC, abstractmethod
+
+from blockops.utils.params import ParamClass, setParams
+from blockops.utils.params import PositiveInteger, TaskPoolParam
+from blockops.taskPool import TaskPool
+
+
+class ScheduledTask:
+    """
+    Helper class containing information about scheduled task
+    """
+
+    def __init__(self, proc: int, start: float, end: float, name: str, color: str = 'gray') -> None:
+        """
+        Constructor for ScheduledTask
+
+        Parameters
+        ----------
+        proc : int
+            Process associated to this task
+        start : float
+            Start point
+        end : float
+            End point
+        name : str
+            Name of the task
+        color : str
+            Color of this task
+        """
+        self.proc = proc
+        self.start = start
+        self.name = name
+        self.end = end
+        self.color = color
+
+
+@setParams(
+    taskPool=TaskPoolParam(),
+    nProc=PositiveInteger(),
+    nPoints=PositiveInteger()
+)
+class Scheduler(ABC, ParamClass):
+    """
+    Base class for a scheduler (assigns start points to tasks)
+
+    Parameters
+    ----------
+    taskPool : TaskPool
+        Task pool containing all tasks to be scheduled
+    nProc : int
+        The number of processes
+    nPoints : int
+        The number of blocks
+    """
+
+    NAME = None  # unique name for the schedule
+    IDS = set()  # list of ids that can be used for usage of this schedule
+
+    def __init__(self, taskPool: TaskPool, nProc: int, nPoints: int) -> None:
+        """
+        Constructor for abstract scheduler class
+        """
+        self.schedule = {}
+        self.taskPool = taskPool
+        self.makespan = 0
+        self.nProc = nProc
+        self.startPointProc = np.zeros(self.nProc)
+        self.nPoints = nPoints
+
+    @abstractmethod
+    def computeSchedule(self):
+        """
+        Abstract method.
+
+        Child classes overwrites the method to define schedule
+        """
+        pass
+
+    @staticmethod
+    def getDefaultNProc(N):
+        """Return a default number of processors for a given number of block"""
+        return None
+
+    def getRuntime(self) -> float:
+        """
+        Returns the runtime of a schedule
+
+        Returns
+        -------
+            self.makespan : float
+        Runtime of schedule
+        """
+        return self.makespan
+
+    def plot(self, figName: str, figSize: tuple = (8, 4.8), saveFig: str = "") -> None:
+        """
+        Helper function to plot a schedule
+
+        Parameters
+        ----------
+        figName : str
+            Figure name
+        figSize : tuple
+            Figure size
+        saveFig : str
+            Saves the plot in the file *saveFig* if not equal to ""
+        """
+        fig, ax = plt.subplots(1, 1, figsize=figSize, num=figName)
+        colors = {}
+        for key, value in self.schedule.items():
+            time = value.end - value.start
+            if time > 0:
+                operation = value.name
+                rec = Rectangle((value.start, value.proc + .225), time, .5, color='k', fc=value.color)
+                ax.add_patch(rec)
+                if value.color not in colors:
+                    colors[value.color] = operation
+        ax.set_xlim(0, self.makespan)
+        ax.set_ylim(0, self.nProc)
+        ax.set_yticks(np.linspace(self.nProc - 1, 0, self.nProc) + 0.5)
+        ax.set_yticklabels(['P' + str(i) for i in range(self.nProc - 1, -1, -1)])
+        ax.set_ylabel(ylabel='Processor rank')
+        ax.set_xlabel(xlabel='Computation cost')
+        leg = [Line2D([0],
+                      [0],
+                      marker='o',
+                      color='w',
+                      label=value,
+                      markerfacecolor=key,
+                      markersize=15) for key, value in colors.items()]
+        plt.legend(handles=leg,
+                   title='Task description',
+                   loc='upper center',
+                   bbox_to_anchor=(0.5, 1.25),
+                   ncol=5,
+                   fancybox=True,
+                   shadow=True,
+                   numpoints=1,
+                   fontsize=16)
+        if saveFig != "":
+            fig.savefig(saveFig, bbox_inches='tight', pad_inches=0.5)
+        plt.show()
+
+
+# Dictionary to store all the scheduler implementations
+SCHEDULER: Dict[str, Scheduler] = {}
+
+
+def register(cls: Scheduler) -> Scheduler:
+    for stringID in cls.IDS:
+        SCHEDULER[stringID] = cls
+    return cls
+
+
+# Import submodules to register Scheduler classes in SCHEDULER
+__all__ = [name for name in locals().keys() if not name.startswith('__')]
+for loader, moduleName, _ in pkgutil.walk_packages(__path__):
+    __all__.append(moduleName)
+    __import__(__name__ + '.' + moduleName)
+
+
+def getSchedule(taskPool: TaskPool, nProc: int, nPoints: int, schedulerType: str) -> Scheduler:
+    """
+    Helper function to get scheduler and compute schedule
+
+    Parameters
+    ----------
+    taskPool : str
+        Figure name
+    nProc: int, None
+        Number of procs
+    nPoints: int
+        Number of blocks
+    schedulerType: str
+        Name of the scheduler
+
+    Returns
+    -------
+    scheduler : Scheduler
+        Scheduler containing schedule
+    """
+    SchedulerClass = SCHEDULER[schedulerType]
+    nProc = SchedulerClass.getDefaultNProc(nPoints - 1) if nProc is None else nProc
+    scheduler = SchedulerClass(taskPool=taskPool, nProc=nProc, nPoints=nPoints)
+    scheduler.computeSchedule()
+    return scheduler

blockops/scheduler/listScheduler.py

@@ -0,0 +1,90 @@
+import sympy as sy
+from abc import ABC, abstractmethod
+
+from blockops.scheduler import Scheduler, TaskPool
+from blockops.utils.params import setParams
+
+@setParams(
+)
+class listScheduler(Scheduler, ABC):
+    """
+    Abstract list scheduler class
+    """
+
+    NAME = ""
+    IDS = {}
+
+    def __init__(self, taskPool: TaskPool, nProc: int, nPoints: int) -> None:
+        """
+        Constructor for PinTBlockByBlock scheduler
+        """
+        super().__init__(taskPool=taskPool, nProc=nProc, nPoints=nPoints)
+
+        # Use three list to divide tasks:
+        #   - availableTasks: All prerequisites are fulfilled
+        #   - notAvailableTasks: At least one prerequisite is not fulfilled
+        #   - finishedTasks: Finished tasks
+        self.availableTasks = set([key for key, value in self.taskPool.pool.items() if len(value.dep) == 0])
+        self.notAvailableTasks = set([key for key, value in self.taskPool.pool.items() if len(value.dep) > 0])
+        self.finishedTasks = set([])
+
+    @abstractmethod
+    def pickTask(self):
+        """
+        Abstract method
+        Contains logic to pick the next task to schedule.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def assignTask(self, taskName: sy.Symbol) -> None:
+        """
+        Abstract method for assigning task
+
+        Parameters
+        ----------
+        taskName : sy.Symbol
+            The name of the task to be scheduled
+        """
+        raise NotImplementedError()
+
+    def updateLists(self, taskName: sy.Symbol) -> None:
+        """
+        Updates all three lists after task *taskName* is scheduled
+
+        Parameters
+        ----------
+        taskName : sy.Symbol
+            The name of the last scheduled task
+        """
+        # Remove task from available task and add to finished
+        self.finishedTasks.add(taskName)
+        self.availableTasks.remove(taskName)
+
+        # Iterating on all following tasks
+        task = self.taskPool.getTask(name=taskName)
+        for item in task.followingTasks:
+            folTask = self.taskPool.getTask(name=item)
+            # Check if all dependencies are finished
+            if sum(el in self.finishedTasks for el in folTask.dep) == len(folTask.dep):
+                # Check if task is not already finished or available
+                if item not in self.finishedTasks and item not in self.availableTasks:
+                    # Add task to available tasks and remove from non available
+                    self.availableTasks.add(item)
+                    self.notAvailableTasks.remove(item)
+
+    def computeSchedule(self) -> None:
+        """
+        Main routine to compute a schedule.
+        The scheduler is based on the following routine:
+
+        As long as there are tasks that can be scheduled:
+            - Choose one tasks based on logic (see pickTasks)
+            - Assign task, i.e. compute the earliest possible start
+              on the corresponding process
+            - Update the three lists of tasks
+        """
+        while len(self.availableTasks) != 0:
+            taskName = self.pickTask()
+            self.assignTask(taskName=taskName)
+            self.updateLists(taskName=taskName)

blockops/scheduler/lowestCostFirst.py

@@ -0,0 +1,80 @@
+import numpy as np
+import sympy as sy
+
+from blockops.scheduler import register, ScheduledTask, TaskPool
+from blockops.scheduler.listScheduler import listScheduler
+from blockops.utils.params import setParams
+
+
+@register
+@setParams(
+)
+class LowestCostFirst(listScheduler):
+    """
+    Calculates a schedule using a list approach where the task with the
+    lowest cost is schedules first. This assumes that the cheapest tasks
+    corresponds to lower lever tasks which helps most to enable new
+    computations.
+    """
+    NAME = "LowestCostFirst"
+    IDS = {"LOWEST-COST-FIRST", "LCF"}
+
+    def __init__(self, taskPool: TaskPool, nProc: int, nPoints: int) -> None:
+        """
+        Constructor for LowestCostFirst scheduler
+        """
+        super().__init__(taskPool=taskPool, nProc=nProc, nPoints=nPoints)
+
+    def pickTask(self) -> sy.Symbol:
+        """
+        Contains logic to pick the next task to schedule.
+
+        Selects tasks based on the following priotirization:
+            - Task with lowest costs
+
+        Returns
+        -------
+        taskName : sy.Symbol
+            Name of the task to be scheduled next
+        """
+        tmp = [[self.taskPool.getTask(item).cost,
+                self.taskPool.getTask(item).iteration,
+                self.taskPool.getTask(item).block, item] for item in self.availableTasks]
+        return min(tmp, key=lambda x: (x[0], x[1], x[2]))[3]
+
+    def assignTask(self, taskName: sy.Symbol) -> None:
+        """
+        Computes the earliest starting point for the task *taskName*.
+        The starting point depends on the prerequisite tasks of *taskName*.
+
+        Parameters
+        ----------
+        taskName : sy.Symbol
+            The name of the task to be scheduled
+        """
+        # Get task
+        task = self.taskPool.getTask(taskName)
+
+        # Compute the minimum start time based on the prerequisites
+        minimal_start_time = 0
+        for depTask in task.dep:
+            if self.schedule[depTask].end > minimal_start_time:
+                minimal_start_time = self.schedule[depTask].end
+
+        # Get the first process who is free for the minimal start time
+        tmp = np.where(self.startPointProc <= minimal_start_time)[0]
+        if len(tmp) > 0:
+            proc = tmp[0]
+        else:
+            proc = np.argmin(self.startPointProc)
+            minimal_start_time = self.startPointProc[proc]
+        self.schedule[taskName] = ScheduledTask(proc=proc,
+                                                start=minimal_start_time,
+                                                end=minimal_start_time + task.cost,
+                                                name=task.opType,
+                                                color=task.color)
+        self.startPointProc[proc] = self.schedule[taskName].end
+
+        # Update minimum runtime if required
+        if self.schedule[taskName].end > self.makespan:
+            self.makespan = self.schedule[taskName].end

blockops/scheduler/optimal.py

@@ -0,0 +1,70 @@
+import numpy as np
+import sympy as sy
+
+from blockops.scheduler import register, ScheduledTask, TaskPool
+from blockops.scheduler.listScheduler import listScheduler
+from blockops.utils.params import setParams
+
+
+@register
+@setParams(
+)
+class Optimal(listScheduler):
+    """
+    Calculates an optimal schedule using a simple greedy approach.
+    Assumes unlimited processes and does not minimize the number of processes.
+    """
+    NAME = "Optimal"
+    IDS = {"OPTIMAL", "OPT"}
+
+    def __init__(self, taskPool: TaskPool, nProc: int, nPoints: int) -> None:
+        """
+        Constructor for optimal scheduler
+        """
+        super().__init__(taskPool=taskPool, nProc=nProc, nPoints=nPoints)
+        self.startPointProc = np.zeros(20000)
+
+    def pickTask(self) -> sy.Symbol:
+        """
+        Contains logic to pick the next task to schedule
+
+        Choose the cheapest task (Typically corresponds to
+        coarse solves that often allow new tasks)
+        Random choices are possible
+
+        Returns
+        -------
+        taskName : sy.Symbol
+            Name of the task to be scheduled next
+        """
+        tmp = [[self.taskPool.getTask(item).cost, item] for item in self.availableTasks]
+        return min(tmp, key=lambda x: x[0])[1]
+
+    def assignTask(self, taskName):
+        """
+        Computes the earliest starting point for the task *taskName*.
+        Assigns the task to process as soon as possible
+        """
+        task = self.taskPool.getTask(taskName)
+        minimal_start_time = 0
+        for depTask in task.dep:
+            if self.schedule[depTask].end > minimal_start_time:
+                minimal_start_time = self.schedule[depTask].end
+        # Get the first process who is free for the minimal start time
+        proc = next(x[0] for x in enumerate(self.startPointProc) if x[1] <= minimal_start_time)
+        self.schedule[taskName] = ScheduledTask(proc=proc,
+                                                start=minimal_start_time,
+                                                end=minimal_start_time + task.cost,
+                                                name=task.opType,
+                                                color=task.color)
+        self.startPointProc[proc] = self.schedule[taskName].end
+        if self.schedule[taskName].end > self.makespan:
+            self.makespan = self.schedule[taskName].end
+
+    def computeSchedule(self):
+        """
+        Main routine to compute a schedule.
+        Calls the parent function and updates the number of processes used
+        """
+        super(Optimal, self).computeSchedule()
+        self.nProc = len(np.where(self.startPointProc != 0)[0])

blockops/scheduler/pintBlockByBlock.py

@@ -0,0 +1,124 @@
+import numpy as np
+import sympy as sy
+
+from blockops.scheduler import register, ScheduledTask, TaskPool
+from blockops.scheduler.listScheduler import listScheduler
+from blockops.utils.params import setParams
+
+
+@register
+@setParams(
+)
+class PinTBlockByBlock(listScheduler):
+    """
+    Computes standard parallel-in-time schedule based on block-by-block basis
+    """
+
+    NAME = "PinT Block-by-Block"
+    IDS = {'BLOCK-BY-BLOCK', 'BbB'}
+
+    def __init__(self, taskPool: TaskPool, nProc: int, nPoints: int) -> None:
+        """
+        Constructor for PinTBlockByBlock scheduler
+        """
+        super().__init__(taskPool=taskPool, nProc=nProc, nPoints=nPoints)
+
+        # Compute which time points are located on which process
+        self.distribution = np.array([int(self.nPoints / self.nProc + 1)] * (self.nPoints % self.nProc) +
+                                     [int(self.nPoints / self.nProc)] * (self.nProc - self.nPoints % self.nProc))
+        self.pointToProc = {}
+        start = 0
+        for i in range(self.nProc):
+            for j in range(start, start + self.distribution[i]):
+                self.pointToProc[j] = i
+            start += self.distribution[i]
+
+    def pickTask(self) -> sy.Symbol:
+        """
+        Contains logic to pick the next task to schedule.
+
+        Selects tasks based on the following priotirization:
+            - Earliest iteration first
+            - Latest time first
+
+        Returns
+        -------
+        taskName : sy.Symbol
+            Name of the task to be scheduled next
+        """
+
+        # Pick the first task
+        taskName = next(iter(self.availableTasks))
+        task = self.taskPool.getTask(name=taskName)
+        tmpIt = task.iteration
+        tmpB = task.block
+
+        # Iterates over all tasks and checks if another task has higher priority
+        for item in self.availableTasks:
+            tmp = self.taskPool.getTask(name=item)
+            if tmp.iteration < tmpIt:
+                taskName = item
+                task = tmp
+                tmpIt = task.iteration
+                tmpB = task.block
+            elif tmp.iteration == tmpIt:
+                if tmp.block > tmpB:
+                    taskName = item
+                    task = tmp
+                    tmpIt = task.iteration
+                    tmpB = task.block
+            else:
+                continue
+        return taskName
+
+    def assignTask(self, taskName: sy.Symbol) -> None:
+        """
+        Computes the earliest starting point for the task *taskName*.
+        The starting point depends on the prerequisite tasks of *taskName*
+        and the process associated with the task
+
+        Parameters
+        ----------
+        taskName : sy.Symbol
+            The name of the task to be scheduled
+        """
+
+        # Get task object
+        task = self.taskPool.getTask(taskName)
+
+        # Compute earliest start point
+        possibleStartTime = self.startPointProc[self.pointToProc[task.block]]
+        tmp_commu = 0
+        for depTask in task.dep:
+            if self.schedule[depTask].end + tmp_commu > possibleStartTime:
+                possibleStartTime = self.schedule[depTask].end + tmp_commu
+
+        self.schedule[taskName] = ScheduledTask(proc=self.pointToProc[task.block],
+                                                start=possibleStartTime,
+                                                end=possibleStartTime + task.cost,
+                                                name=task.opType,
+                                                color=task.color)
+
+        self.startPointProc[self.pointToProc[task.block]] = self.schedule[taskName].end
+
+        # Update makespan if required
+        if self.schedule[taskName].end > self.makespan:
+            self.makespan = self.schedule[taskName].end
+
+    @staticmethod
+    def getDefaultNProc(N: int) -> int:
+        """
+        Returns the standard choice of processes for this scheduler
+        based on the number of blocks
+
+        Parameters
+        ----------
+        N : int
+            TODO
+
+        Returns
+        -------
+        N : int
+            TODO
+        """
+        return N

blockops/utils/params.py

@@ -10,6 +10,9 @@
 import copy
 import numpy as np
 
+from blockops.taskPool import TaskPool
+
+
 # -----------------------------------------------------------------------------
 # Base classes
 # -----------------------------------------------------------------------------
@@ -34,7 +37,7 @@ class Parameter(object):
     value = None
 
     def error(self, value, reason):
-        reason+= f" ({self.pType})"
+        reason += f" ({self.pType})"
         raise ParamError(self.name, value, reason)
 
     @property
@@ -102,7 +105,7 @@ def extractParamDocs(cls, *names):
             docLines = docs[iStart:].splitlines()[2:]
             descr = []
             for line in docLines:
-                if line.startswith(8*' '):
+                if line.startswith(8 * ' '):
                     descr.append(line.strip())
                 elif line.strip() == '':
                     continue
@@ -131,7 +134,7 @@ def wrapper(cls):
 
         # Ignore **kwargs type arguments
         sigParams = {name: par for name, par in sig.parameters.items()
-                      if par.kind != par.VAR_KEYWORD}
+                     if par.kind != par.VAR_KEYWORD}
 
         # Add parameter object to the class PARAMS dictionnary
         for name, pType in kwargs.items():
@@ -272,3 +275,12 @@ def check(self, value):
         if not isinstance(value, bool):
             self.error(value, "not of boolean type")
         return True
+
+
+class TaskPoolParam(Parameter):
+    """Accepts a taskPool class"""
+
+    def check(self, value):
+        if not isinstance(value, TaskPool):
+            self.error(value, "not of TaskPool type")
+        return True

notebook/01_baseTuto.ipynb

@@ -192,7 +192,7 @@ class LowestCostFirst(Schedule):
     that the cheapest tasks corresponds to lower lever tasks which helps most to enable new computations.
     """
     NAME = "LowestCostFirst"
-    IDS = {"LOWEST-COST-FIRST", "LCF"}
+    IDS = {"LOWEST-COST-FIRST", "LCF", "LowestCostFirst"}
 
     def __init__(self, *args: object, **kwargs: object):
         super().__init__(*args, **kwargs)
@@ -313,12 +313,12 @@ def computeSchedule(self):
         self.nProc = len(np.where(self.startPointProc != 0)[0])
 
 
-def getSchedule(taskPool: TaskPool, nProc: int, nPoints: int, schedule_type: str
+def getSchedule(taskPool: TaskPool, nProc: int, nPoints: int, scheduleType: str
                 ) -> Schedule:
-    if schedule_type not in SCHEDULE_TYPES:
+    if scheduleType not in SCHEDULE_TYPES:
         raise Exception(f"Schedule {type} not implemented, must be in {list(SCHEDULE_TYPES.keys())}")
     else:
-        ScheduleClass = SCHEDULE_TYPES[schedule_type]
+        ScheduleClass = SCHEDULE_TYPES[scheduleType]
         nProc = ScheduleClass.getDefaultNProc(nPoints - 1) if nProc is None else nProc
         schedule = ScheduleClass(taskPool=taskPool, nProc=nProc, nPoints=nPoints)
         schedule.computeSchedule()

notebook/04_schedules.ipynb

@@ -74,7 +74,7 @@
 efficiencyLCF = np.zeros(nBlocks + 1)
 for k in reqIters:
     speedupLCF[k], efficiencyLCF[k], _ = algo.getPerformances(
-        N=nBlocks, K=k, nProc=nBlocks + 1, schedule_type='LCF')
+        N=nBlocks, K=k, nProc=nBlocks + 1, schedulerType='LCF')
 nSpeedup = speedupLCF[nIter]
 nEfficiency = efficiencyLCF[nIter]
 
@@ -89,7 +89,7 @@
 efficiencyBbB = np.zeros(nBlocks + 1)
 for k in reqIters:
     speedupBbB[k], efficiencyBbB[k], _ = algo.getPerformances(
-        N=nBlocks, K=k, schedule_type='BbB')
+        N=nBlocks, K=k, schedulerType='BbB')
 nSpeedup = speedupBbB[nIter]
 nEfficiency = efficiencyBbB[nIter]
 

blockops/schedule.py old/schedule.py

@@ -39,5 +39,5 @@
             for blockIter in [parareal,pararealSC,abj, abgs]:
                 print(f'N: {nBlocks}, K: {k}, method: {method}, blockIter {blockIter.name}')
                 start = time.time()
-                a = blockIter.getRuntime(N=nBlocks, K=k, nProc=nBlocks, schedule_type=method)
+                a = blockIter.getRuntime(N=nBlocks, K=k, nProc=nBlocks, schedulerType=method)
                 print(f'{blockIter.name} runtime for N={nBlocks}, K={k}: {time.time()-start}, {a}')

scripts/03_pintIter.py

@@ -75,7 +75,7 @@
 efficiencyBbB = np.zeros(nBlocks + 1)
 for k in reqIters:
     speedupBbB[k], efficiencyBbB[k], _ = algo.getPerformances(
-        N=nBlocks, K=k, schedule_type='BbB')
+        N=nBlocks, K=k, schedulerType='BbB')
 nSpeedup = speedupBbB[nIter]
 nEfficiency = efficiencyBbB[nIter]