File size: 6,379 Bytes
5e797a4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 | """Module in charge of parallelizing the execution of tasks."""
import math
from multiprocessing import Process, Queue
from haddock import log
from haddock.core.typing import (
AnyT,
FilePath,
Generator,
Optional,
Sequence,
SupportsRunT,
Union,
)
from haddock.libs.libutil import parse_ncores
def split_tasks(lst: Sequence[AnyT], n: int) -> Generator[Sequence[AnyT], None, None]:
"""Split tasks into N-sized chunks."""
n = math.ceil(len(lst) / n)
for j in range(0, len(lst), n):
chunk = lst[j : n + j]
yield chunk
def get_index_list(nmodels, ncores):
"""
Optimal distribution of models among cores
Parameters
----------
nmodels : int
Number of models to be distributed.
ncores : int
Number of cores to be used.
Returns
-------
index_list : list
List of model indexes to be used for the parallel scanning.
"""
if nmodels < 1:
raise ValueError(f"nmodels ({nmodels})) must be greater than 0")
if ncores < 1:
raise ValueError(f"ncores ({ncores}) must be greater than 0")
spc = nmodels // ncores
# now the remainder
rem = nmodels % ncores
# now the list of indexes to be used for the SCAN calculation
index_list = [0]
for core in range(ncores):
if core < rem:
index_list.append(index_list[-1] + spc + 1)
else:
index_list.append(index_list[-1] + spc)
return index_list
class GenericTask:
"""Generic task to be executed."""
def __init__(self, function, *args, **kwargs):
if not callable(function):
raise TypeError("The 'function' argument must be callable")
self.function = function
self.args = args
self.kwargs = kwargs
def run(self):
return self.function(*self.args, **self.kwargs)
class Worker(Process):
"""Work on tasks."""
def __init__(self, tasks: Sequence[SupportsRunT], results: Queue) -> None:
super(Worker, self).__init__()
self.tasks = tasks
self.result_queue = results
log.debug(f"Worker ready with {len(self.tasks)} tasks")
def run(self) -> None:
"""Execute tasks."""
results = []
for task in self.tasks:
r = None
try:
r = task.run()
except Exception as e:
log.warning(f"Exception in task execution: {e}")
results.append(r)
# Put results into the queue
self.result_queue.put(results)
# Signal completion by putting a unique identifier into the queue
self.result_queue.put(f"{self.name}_done")
# log.debug(f"{self.name} executed")
class Scheduler:
"""Schedules tasks to run in multiprocessing."""
def __init__(
self,
tasks: list[SupportsRunT],
ncores: Optional[int] = None,
max_cpus: bool = False,
) -> None:
"""
Schedule tasks to a defined number of processes.
Parameters
----------
tasks : list
The list of tasks to execute. Tasks must have method `run()`.
ncores : None or int
The number of cores to use. If `None` is given uses the
maximum number of CPUs allowed by
`libs.libututil.parse_ncores` function.
"""
self.max_cpus = max_cpus
self.num_tasks = len(tasks)
self.num_processes = ncores # first parses num_cores
self.queue: Queue = Queue()
self.results: list = []
# Sort the tasks by input_file name and its length, so we know that 2 comes before 10
### Q? Whys is this necessary?
# Only CNSJobs can be sorted like this
if all(hasattr(t, "input_file") for t in tasks):
task_name_dic: dict[int, tuple[FilePath, int]] = {}
for i, t in enumerate(tasks):
task_name_dic[i] = (t.input_file, len(str(t.input_file))) # type: ignore
sorted_task_list: list[SupportsRunT] = []
for e in sorted(task_name_dic.items(), key=lambda x: (x[0], x[1])):
idx = e[0]
sorted_task_list.append(tasks[idx])
else:
sorted_task_list = tasks
job_list = split_tasks(sorted_task_list, self.num_processes)
self.worker_list = [Worker(jobs, self.queue) for jobs in job_list]
log.info(f"Using {self.num_processes} cores")
log.debug(f"{self.num_tasks} tasks ready.")
@property
def num_processes(self) -> int:
"""Number of processors to use.""" # noqa: D401
return self._ncores
@num_processes.setter
def num_processes(self, n: Union[str, int, None]) -> None:
self._ncores = parse_ncores(
n,
njobs=self.num_tasks,
max_cpus=self.max_cpus,
)
log.debug(f"Scheduler configured for {self._ncores} cpu cores.")
def run(self) -> None:
"""Run tasks in parallel."""
try:
for w in self.worker_list:
w.start()
# Collect results until all workers have signaled completion
all_results = []
num_workers = len(self.worker_list)
completed_workers = 0
while completed_workers < num_workers:
result = self.queue.get()
if isinstance(result, str) and result.endswith("_done"):
completed_workers += 1
else:
all_results.append(result)
for w in self.worker_list:
w.join()
self.results = [item for sublist in all_results for item in sublist]
log.info(f"{self.num_tasks} tasks finished")
except KeyboardInterrupt as err:
# Q: why have a keyboard interrupt here?
# A: To have a controlled break if the user Ctrl+c during CNS run
self.terminate()
# this raises sends the error to libs.libworkflow.Step
# if Scheduler is used independently the error will propagate to
# whichever has to catch it
raise err
def terminate(self) -> None:
"""Terminate tasks in a controlled way."""
for worker in self.worker_list:
worker.terminate()
log.info("The workers terminated in a controlled way")
|