def inspect_init(self): """Use the initialization `PwCalculation` to determine the required resource and parallelization settings.""" calculation = self.ctx.calculation_init if not calculation.is_finished_ok: return self.exit_codes.ERROR_INITIALIZATION_CALCULATION_FAILED # Get automated parallelization settings parallelization = get_pw_parallelization_parameters(calculation, **self.ctx.automatic_parallelization) # Note: don't do this at home, we are losing provenance here. This should be done by a calculation function node = orm.Dict(dict=parallelization).store() self.out('automatic_parallelization', node) self.report('results of automatic parallelization in {}<{}>'.format(node.__class__.__name__, node.pk)) options = self.ctx.inputs.metadata['options'] base_resources = options.get('resources', {}) goal_resources = parallelization['resources'] scheduler = calculation.computer.get_scheduler() resources = create_scheduler_resources(scheduler, base_resources, goal_resources) cmdline = self.ctx.inputs.settings.get('cmdline', []) cmdline = cmdline_remove_npools(cmdline) cmdline.extend(['-nk', str(parallelization['npools'])]) # Set the new cmdline setting and resource options self.ctx.inputs.settings['cmdline'] = cmdline self.ctx.inputs.metadata['options'] = update_mapping(options, {'resources': resources}) # Remove the only initialization flag self.ctx.inputs.settings.pop('ONLY_INITIALIZATION') return
def run_init(self): """Run an initialization `PwCalculation` that will exit after the preamble. In the preamble, all the relevant dimensions of the problem are computed which allows us to make an estimate of the required resources and what parallelization flags need to be set. """ inputs = self.ctx.inputs # Set the initialization flag and the initial default options inputs.settings['ONLY_INITIALIZATION'] = True inputs.metadata['options'] = update_mapping(inputs.metadata['options'], get_default_options()) # Prepare the final input dictionary inputs = prepare_process_inputs(PwCalculation, inputs) running = self.submit(PwCalculation, **inputs) self.report('launching initialization {}<{}>'.format(running.pk, self._process_class.__name__)) return ToContext(calculation_init=running)
def inspect_init(self): """ Use the initialization PwCalculation to determine the required resource settings for the requested calculation based on the settings in the automatic_parallelization input """ calculation = self.ctx.calculation_init if not calculation.has_finished_ok(): self.abort_nowait( 'the initialization calculation did not finish successfully') return # Get automated parallelization settings parallelization = get_pw_parallelization_parameters( calculation, **self.ctx.automatic_parallelization) node = ParameterData(dict=parallelization) self.out('automatic_parallelization', node) self.report('results of automatic parallelization in {}<{}>'.format( node.__class__.__name__, node.pk)) options = self.ctx.inputs._options base_resources = options.get('resources', {}) goal_resources = parallelization['resources'] scheduler = calculation.get_computer().get_scheduler() resources = create_scheduler_resources(scheduler, base_resources, goal_resources) cmdline = self.ctx.inputs.settings.get('cmdline', []) cmdline = cmdline_remove_npools(cmdline) cmdline.extend(['-nk', str(parallelization['npools'])]) # Set the new cmdline setting and resource options self.ctx.inputs.settings['cmdline'] = cmdline self.ctx.inputs._options = update_mapping(options, {'resources': resources}) # Remove the only initialization flag self.ctx.inputs.settings.pop('ONLY_INITIALIZATION') return
def run_init(self): """ Run a first dummy pw calculation that will exit straight after initialization. At that point it will have generated some general output pertaining to the dimensions of the calculation which we can use to distribute available computational resources """ inputs = self.ctx.inputs # Set the initialization flag and the initial default options inputs.settings['ONLY_INITIALIZATION'] = True inputs._options = update_mapping(inputs['_options'], get_default_options()) # Prepare the final input dictionary inputs = self._prepare_process_inputs(inputs) process = PwCalculation.process() running = submit(process, **inputs) self.report('launching initialization PwCalculation<{}>'.format(running.pid)) return ToContext(calculation_init=running)