def run(self, strong_scaled=1, autoterminate=True, queue='high', walltime=1440): pipelines = set() input_data = list() for protocol in self._protocols: gen_pipeline = protocol.generate_pipeline() pipelines.add(gen_pipeline) input_data.extend(protocol.input_data) self.ids[protocol.id()] = gen_pipeline # protocol.id is the uuid, gen_pipeline.uid is the pipeline self.total_replicas += protocol.replicas self._cores = self._cores * self.total_replicas print 'Running on', self._cores, 'cores.' res_dict = {'resource': 'ncsa.bw_aprun', 'walltime': walltime, 'cores': int(self._cores*strong_scaled), 'project': 'bamm', 'queue': queue, 'access_schema': 'gsissh'} # Create Resource Manager object with the above resource description resource_manager = ResourceManager(res_dict) resource_manager.shared_data = input_data # Create Application Manager self.app_manager = AppManager(hostname=self._hostname, port=self._port, autoterminate=autoterminate) self.app_manager.resource_manager = resource_manager self.app_manager.assign_workflow(pipelines) self._prof.prof('execution_run') print 'Running...' self.app_manager.run() # this method is blocking until all pipelines show state = completed
pipes_set.add(get_pipeline(num_tasks)) # Create a dictionary describe four mandatory keys: # resource, walltime, cores and project # resource is 'local.localhost' to execute locally res_dict = { 'resource': res_name, 'walltime': res_coll[res_name]['walltime'], 'cores': num_tasks, 'project': res_coll[res_name]['project'], 'queue': res_coll[res_name]['queue'], 'access_schema': res_coll[res_name]['schema'] } # Create Resource Manager object with the above resource description rman = ResourceManager(res_dict) # Create Application Manager appman = AppManager() # Assign resource manager to the Application Manager appman.resource_manager = rman # Assign the workflow as a set of Pipelines to the Application Manager appman.assign_workflow(pipes_set) # Run the Application Manager appman.run()
'resource': Kconfig.REMOTE_HOST, 'walltime': Kconfig.WALLTIME, 'cores': Kconfig.PILOTSIZE, 'cpus': Kconfig.PILOTSIZE, 'cpu_processes': Kconfig.num_CUs_per_MD_replica, #PILOTSIZE, 'gpus': Kconfig.PILOTSIZE / 16, 'project': Kconfig.ALLOCATION, 'queue': Kconfig.QUEUE, 'access_schema': 'gsissh' } else: print("use_gpus not recognized") print res_dict # Create Resource Manager object with the above resource description rman = ResourceManager(res_dict) # Data common to multiple tasks -- transferred only once to common staging area rman.shared_data = [ Kconfig.md_input_file, Kconfig.md_run_file, Kconfig.lsdm_config_file, '%s/spliter.py' % Kconfig.helper_scripts, '%s/gro.py' % Kconfig.helper_scripts, #'%s/run.py' % Kconfig.helper_scripts, #'%s/run_openmm.py' % Kconfig.helper_scripts, #'%s/pre_analyze.py' % Kconfig.helper_scripts, '%s/pre_analyze_openmm.py' % Kconfig.helper_scripts, '%s/post_analyze.py' % Kconfig.helper_scripts, #'%s/selection.py' % Kconfig.helper_scripts, '%s/selection-cluster.py' % Kconfig.helper_scripts, '%s/reweighting.py' % Kconfig.helper_scripts
'resource': Kconfig.REMOTE_HOST, 'walltime': Kconfig.WALLTIME, #'cores': Kconfig.PILOTSIZE, 'cpus': Kconfig.NODESIZE * Kconfig.CPUs_per_NODE, #'cpu_processes': Kconfig.num_CUs_per_MD_replica,#PILOTSIZE, 'gpus': Kconfig.NODESIZE, 'project': Kconfig.ALLOCATION, 'queue': Kconfig.QUEUE, 'access_schema': 'gsissh' } else: print("use_gpus not recognized") print res_dict # Create Resource Manager object with the above resource description rman = ResourceManager(res_dict) # Data common to multiple tasks -- transferred only once to common staging area rman.shared_data = [ Kconfig.md_dir + Kconfig.md_input_file, Kconfig.md_dir + Kconfig.md_run_file, args.Kconfig, #'%s > %s/%s' % (args.Kconfig, combined_path, args.Kconfig), #Kconfig.lsdm_config_file, #'%s/spliter-tica.py' % Kconfig.helper_scripts, '%s/run-tica-msm.py' % Kconfig.helper_scripts, #'%s/run.py' % Kconfig.helper_scripts, #'%s/run_openmm.py' % Kconfig.helper_scripts, #'%s/pre_analyze.py' % Kconfig.helper_scripts, #'%s/pre_analyze_openmm.py' % Kconfig.helper_scripts, #'%s/post_analyze.py' % Kconfig.helper_scripts, #'%s/selection.py' % Kconfig.helper_scripts,
def generate_pipeline(name, stages): #Generate Pipeline for Stream Extraction/Morphological Thinning # Create a Pipeline object p = Pipeline() p.name = 'p1' for s_cnt in range(stages): # Create a Stage object, Stream Extraction s1 = Stage() s1.name = ‘Stage 1’ # Create a Stage object, Morphological Thinning s2 = Stage() s2.name = ‘Stage 2’ # Create Task 1, Stream Extraction t1 = Task() t1.name = 'Task 1' t1.executable = ['sbatch'] # Assign executable to the task t1.arguments = ['$SCRATCH/ashk96/StreamExtraction.bat'] # Assign arguments for the StreamExtraction # Add Task 1 to Stage 1 s1.add_tasks(t1) # Add Stage 1 to the Pipeline p.add_stages(s1) # Create Task 2, Morphological Thinning t2 = Task() t2.name = 'Task 2' t2.executable = ['sbatch'] # Assign executable to the task t2.arguments = ['$SCRATCH/ashk96/Thin_Multi.bat'] # Assign arguments for the task executable # Add Task 2 to Stage 2 s2.add_tasks(t2) # Add Stage 2 to the Pipeline p.add_stages(s2) return p if __name__ == '__main__': p1 = generate_pipeline(name='Stream Extraction', stages=2) res_dict = { 'resource': 'xsede.bridges', 'walltime': 02:00:00, 'cores': 2, 'project': 'TG-MCB090174', 'queue': '', 'schema': 'ssh' } # Create Resource Manager object with the above resource description rman = ResourceManager(res_dict) # Create Application Manager appman = AppManager() # Assign resource manager to the Application Manager appman.resource_manager = rman # Execute pipeline appman.assign_workflow(p1) # Run the Application Manager appman.run()
# resource is 'local.localhost' to execute locally res_dict = { 'resource': 'xsede.stampede', 'walltime': 15, 'cores': total_cores, 'project': 'TG-MCB090174', 'access_schema': 'gsissh' } # Download analysis file from MobleyLab repo os.system( 'curl -O https://raw.githubusercontent.com/MobleyLab/alchemical-analysis/master/alchemical_analysis/alchemical_analysis.py' ) # Create Resource Manager object with the above resource description rman = ResourceManager(res_dict) # Data common to multiple tasks -- transferred only once to common staging area rman.shared_data = [ './CB7G3.gro', './CB7G3.ndx', './CB7G3.top', './CB7G3_template.mdp', './analysis_1.py', './analysis_2.py', './determine_convergence.py', './alchemical_analysis.py', './3atomtypes.itp', './3_GMX.itp', './cucurbit_7_uril_GMX.itp' ] # Create Application Manager appman = AppManager() #appman = AppManager(port=) # if using docker, specify port here. # Assign resource manager to the Application Manager appman.resource_manager = rman
print pilot_cores # Create a dictionary describe four mandatory keys: # resource, walltime, cores and project # resource is 'local.localhost' to execute locally res_dict = { 'resource': res_name, 'walltime': res_coll[res_name]['walltime'], 'cores': pilot_cores, 'project': res_coll[res_name]['project'], 'access_schema': res_coll[res_name]['schema'] } # Create Resource Manager object with the above resource description rman = ResourceManager(res_dict) rman.shared_data = [ './ip_data/input.gro', './ip_data/grompp.mdp', './ip_data/topol.top' ] # Create Application Manager appman = AppManager(port=32769) # Assign resource manager to the Application Manager appman.resource_manager = rman # Assign the workflow as a set of Pipelines to the Application Manager appman.assign_workflow(pipes_set) # Run the Application Manager appman.run()
def run(self, resource=None, walltime=None, strong_scaled=1, queue=None, access_schema=None, dry_run=False): """Run protocols. Parameters ---------- resource: str The specific resource and sub-resource you want to use. walltime: int Wall time in minutes. strong_scaled: float For testing strong scaling. Number of cores will be multiplied by this number before execution. queue: str Name of the queue. If there is a default for your resource that will be used. access_schema: str One of ssh, gsissh, local dry_run: bool Whether to execute the `.run` command or not. """ pipelines = set() shared_data = set() cores = 0 max_cu_count = self.resource.get('max_cu_count', 0) for protocol in self._protocols: gen_pipeline = protocol.generate_pipeline() cu_count = len(gen_pipeline.stages[0].tasks) if max_cu_count and cu_count > max_cu_count: raise ValueError('Resource allows up to {} concurrent CUs. You have {}.'.format(max_cu_count, cu_count)) pipelines.add(gen_pipeline) shared_data.update(protocol.shared_data) cores += protocol.cores cores *= strong_scaled cores += self.resource.get('agent_cores', 0) self.resource['resource_dictionary']['cores'] = cores if resource: self.resource['resource_dictionary']['resource'] = resource if walltime: self.resource['resource_dictionary']['walltime'] = walltime if queue: self.resource['resource_dictionary']['queue'] = queue if access_schema: self.resource['resource_dictionary']['access_schema'] = access_schema logger.info('Using total number of cores: {}.'.format(cores)) logger.info('Resource dictionary:\n{}'.format(pprint.pformat(self.resource['resource_dictionary']))) # Create Resource Manager object with the above resource description resource_manager = ResourceManager(self.resource['resource_dictionary']) resource_manager.shared_data = list(shared_data) # Create Application Manager self._app_manager.resource_manager = resource_manager self._app_manager.assign_workflow(pipelines) logger.info("\n".join("Stage {}: {}*{} cores.". format(i, len(s.tasks), next(iter(s.tasks)).cores) for i, s in enumerate(next(iter(pipelines)).stages))) self._prof.prof('execution_run') logger.info('Running workflow.') if not dry_run: self._app_manager.run() # this method is blocking until all pipelines show state = completed