def core(mpi: MpiContainer = None):
app = QApplication(sys.argv)
dbg.p("Application started", "main")
window = MainWindow(mpi)
window.show()
dbg.p("Window shown", "main")
return app.exec_()
def initialise_slaves(mpi: MpiContainer):
if mpi.is_slave:
if mpi.debug_print:
dbg.p(f"Process {mpi.rank}: Slave initialised", "MpiMethod")
run_methods_parallel(None,
None,
mpi,
use_parallel=True,
shutdown=False)
def run(self) -> None:
dbg.p("Thread running", "WorkerTest")
assert self.func is not None, "Worker function not yet set"
assert self.test_string is not None, "Worker parameter not set"
try:
self.func(self.test_string) # This runs the function in the worker thread
except:
traceback.print_exc()
exctype, value = sys.exc_info()[:2]
self._signals.error.emit((exctype, value, traceback.format_exc()))
finally:
self._signals.test_finished.emit()
def btn_test_clicked(self):
dbg.p("Button clicked", "MyWindow")
new_text = "It works!"
test_thread = TestThread(self.gui_cont.update_label, new_text, self.thread_finished)
test_thread.run()
# Testing TODO Turn this off
####################################
test_list = []
for i in range(25):
test_list.append(Test(i))
self.test_obj_list = test_list
####################################
dbg.p("About to start MpiMethodThread", "MainWindow")
parallel_thread = MpiMethodThread(obj_list=self.test_obj_list,
method_name='change_a',
mpi=self.mpi,
finished_fn=self.thread_finished,
all_returns_fn=self.parallel_change_a_returns,
error_fn=self.parallel_change_a_error,
use_parallel=USE_MPI)
parallel_thread.run()
def run(self) -> None:
if SHOW_DEBUG_COMMANDS:
dbg.p(f"Running MpiMethod thread", "MpiMethodThread")
assert self.obj_list is not None, "obj_list parameter has not been set"
assert self.method_name is not None, "method_name parameter has not been set"
if self.use_parallel:
assert self.mpi is not None, "mpi parameter has not been set"
assert all([hasattr(obj, self.method_name) for obj in self.obj_list]), \
f"At least one of the objects do not have the method {method_name}"
try:
all_returns = run_methods_parallel(
self.obj_list,
self.method_name,
self.mpi,
use_parallel=self.use_parallel,
shutdown=False) # This runs the function in the worker thread
self.sig.all_returns.emit(all_returns)
except:
traceback.print_exc()
exctype, value = sys.exc_info()[:2]
self.sig.error.emit((exctype, value, traceback.format_exc()))
finally:
self.sig.finished.emit()
def update_label(self, new_text):
self.main_window.lblTest.setText(new_text)
dbg.p("Label text updated", "GuiController")
def thread_finished(self):
dbg.p("Thread finished!")
def retire_slaves(mpi: MpiContainer):
if mpi.is_main:
run_methods_parallel(None, None, mpi, use_parallel=True, shutdown=True)
if mpi.debug_print:
dbg.p(f"Process {mpi.rank}: Slave retired", "MpiMethod")
def run_methods_parallel(obj_list: List[Any] = None,
method_name: str = None,
mpi: MpiContainer = None,
use_parallel: bool = True,
shutdown: bool = None):
assert use_parallel == (
mpi is not None), "Mpi not provided, or provided erroneously"
if use_parallel:
if mpi.is_main:
if not shutdown:
scatter_data = make_groups(obj_list,
method_name,
mpi.size,
append_bool=shutdown)
else:
scatter_data = []
for _ in range(mpi.size):
scatter_data.append(('', '', shutdown))
else:
scatter_data = None
scatter_data = mpi.comm.scatter(scatter_data, root=0)
objs_4_parallel, method_name, shutdown = scatter_data
if not shutdown:
objs_return_parallel = []
for obj in objs_4_parallel:
if hasattr(obj, 'name'):
obj_name = getattr(obj, 'name')
else:
obj_name = str(obj)
if not hasattr(obj, method_name):
dbg.p(
f"Process {mpi.rank}: ERROR, {obj_name} does not have method {method_name}"
)
if mpi.is_slave:
run_methods_parallel(None, None, mpi, True, False)
return None
else:
if mpi.debug_print:
dbg.p(
f"Process {mpi.rank}: Running '{method_name}' of {obj_name}"
)
obj_method = getattr(obj, method_name)
obj_return = obj_method()
objs_return_parallel.append(obj_return)
gather_obj_returns = mpi.comm.gather(objs_return_parallel, root=0)
if mpi.is_main:
all_obj_returns = []
for single_gather in gather_obj_returns:
all_obj_returns.extend(single_gather)
return all_obj_returns
if mpi.is_slave:
run_methods_parallel(None, None, mpi, True, False)
return None
else:
return None
else:
if not shutdown:
all_obj_returns = []
for obj in obj_list:
obj_method = getattr(obj, method_name)
obj_return = obj_method()
all_obj_returns.append(obj_return)
return all_obj_returns
else:
return None