def run_checkenv(config): """Runs a simple job that performs some sanity tests, determines AMBER version, etc. """ resource = config.RESOURCE allocation = config.ALLOCATION ############################################################ # The pilot description pdesc = radical.pilot.ComputePilotDescription() pdesc.resource = resource pdesc.runtime = 5 # minutes pdesc.cores = 4 pdesc.project = allocation pdesc.cleanup = False ############################################################ # The checkenv task mdtd = MDTaskDescription() mdtd.kernel = "NAMD" mdtd_bound = mdtd.bind(resource=resource) task_desc = radical.pilot.ComputeUnitDescription() task_desc.environment = mdtd_bound.environment task_desc.pre_exec = mdtd_bound.pre_exec task_desc.executable = mdtd_bound.executable task_desc.arguments = mdtd_bound.arguments task_desc.mpi = mdtd_bound.mpi task_desc.cores = 1 # --version can only run on one core. hangs otherwise.g ############################################################ # Call the batch runner br = BatchRunner(config=config) finished_units = br.run(pilot_description=pdesc, cu_descriptions=task_desc) print "\nNOTE: Task state 'Failed' is ok, as long as the 'info' output show up under RESULT." print "\nRESULT:\n" output_line_by_line = string.split(finished_units.stdout, '\n') for line in output_line_by_line: if "Info:" in line: print line br.close()
def run_checkenv(config): """Runs a simple job that performs some sanity tests, determines AMBER version, etc. """ resource = config.RESOURCE allocation = config.ALLOCATION ############################################################ # The pilot description pdesc = radical.pilot.ComputePilotDescription() pdesc.resource = resource pdesc.runtime = 5 # minutes pdesc.cores = 4 pdesc.project = allocation pdesc.cleanup = False pdesc.sandbox = config.WORKDIR ############################################################ # The checkenv task mdtd = MDTaskDescription() mdtd.kernel = "MMPBSA" mdtd.arguments = ["--version"] mdtd_bound = mdtd.bind(resource=resource) task_desc = radical.pilot.ComputeUnitDescription() task_desc.environment = mdtd_bound.environment task_desc.pre_exec = mdtd_bound.pre_exec task_desc.executable = mdtd_bound.executable task_desc.arguments = mdtd_bound.arguments task_desc.mpi = mdtd_bound.mpi task_desc.cores = 1 # --version can only run on one core. hangs otherwise.g ############################################################ # Call the batch runner br = BatchRunner(config=config) finished_units = br.run(pilot_description=pdesc, cu_descriptions=task_desc) print "\nRESULT:\n" print finished_units.stdout br.close()
mmpbsa_test_task.environment = mdtd_bound.environment mmpbsa_test_task.pre_exec = mdtd_bound.pre_exec mmpbsa_test_task.executable = mdtd_bound.executable mmpbsa_test_task.arguments = mdtd_bound.arguments mmpbsa_test_task.mpi = mdtd_bound.mpi mmpbsa_test_task.cores = 4 mmpbsa_test_task.input_data = ["/%s/nmode.5h.py" % os.getcwd(), "/%s/com.top.2" % os.getcwd(), "/%s/rec.top.2" % os.getcwd(), "/%s/lig.top" % os.getcwd(), "/%s/rep1.traj" % os.getcwd()] ############################################################ # Call the batch runner br = BatchRunner(config=config) finished_units = br.run(pilot_description=pdesc, cu_descriptions=mmpbsa_test_task) print "\nRESULT:\n" print finished_units.stdout br.close() ############################################################ # Try to remove the sample input data - silently fail on error. try: for key, val in sampledata.iteritems(): os.remove("./%s" % key) except Exception: pass
def run_workload(config, workload): # """Runs a workload. # """ server = config.SERVER dbname = config.DBNAME maxcpus = config.MAXCPUS resource = config.RESOURCE username = config.USERNAME allocation = config.ALLOCATION # We cannot allocate more than "maxcpus". If the number of tasks is # smaller than 'maxcpus', we chose the closest increment of 16. If it # is larger, we use "maxcpus" and adjust the runtime of the pilot. # NOTE: currently, we assume (near) homogenous runtime among all tasks. task_runtime = workload[0]["runtime"] cores = 0 for task in workload: cores += task["cores"] if cores < maxcpus: pilot_size = cores pilot_runtime = task_runtime else: pilot_size = maxcpus pilot_runtime = task_runtime * (len(workload)/maxcpus) if len(workload)%maxcpus > 0: pilot_runtime += task_runtime print "\n * Number of tasks: %s" % len(workload) print " * Pilot size (# cores): %s" % pilot_size print " * Pilot runtime: %s\n" % pilot_runtime ############################################################ # The pilot description pdesc = radical.pilot.ComputePilotDescription() pdesc.resource = resource pdesc.runtime = pilot_runtime pdesc.cores = pilot_size pdesc.project = allocation pdesc.cleanup = False ############################################################ # Workload definition tasknum = 0 all_tasks = [] # Create CU descriptions from workload taks... for task in workload: tasknum += 1 parmfile = task["parmfile"] parmfile_basen = os.path.basename(parmfile) coordinates = task["coordinates"] coordinates_basen = os.path.basename(coordinates) conskfile = task["conskfile"] coordinates_basen = os.path.basename(conskfile) input = task["input"] input_basen = os.path.basename(input) output = task["output"] mdtd = MDTaskDescription() mdtd.kernel = "NAMD" mdtd.arguments = ["{0}".format(input_basen)] mdtd_bound = mdtd.bind(resource=resource) mmpbsa_task = radical.pilot.ComputeUnitDescription() mmpbsa_task.environment = mdtd_bound.environment mmpbsa_task.pre_exec = mdtd_bound.pre_exec mmpbsa_task.executable = mdtd_bound.executable mmpbsa_task.arguments = mdtd_bound.arguments mmpbsa_task.mpi = mdtd_bound.mpi mmpbsa_task.cores = task["cores"] mmpbsa_task.name = task["name"] mmpbsa_task.input_data = [parmfile, coordinates, conskfile, input] mmpbsa_task.output_data = ["STDOUT > %s" % output] all_tasks.append(mmpbsa_task) ############################################################ # Call the batch runner br = BatchRunner(config=config) finished_units = br.run(pilot_description=pdesc, cu_descriptions=all_tasks) if type(finished_units) != list: finished_units = [finished_units] print "\nDONE" print "=============================================================================\n" for unit in finished_units: if unit.state == radical.pilot.DONE: t_start = unit.start_time t_stop = unit.stop_time t_run = t_stop - t_start else: t_run = "failed" local_output = unit.description.output_data[0].split(" > ")[1] print " o Task {0} RUNTIME {1} OUTPUT: {2}".format(unit.description.name, t_run, local_output) br.close()
def run_workload(config, workload): # """Runs a workload. # """ server = config.SERVER dbname = config.DBNAME maxcpus = config.MAXCPUS resource = config.RESOURCE username = config.USERNAME allocation = config.ALLOCATION # We cannot allocate more than "maxcpus". If the number of tasks is # smaller than 'maxcpus', we chose the closest increment of 16. If it # is larger, we use "maxcpus" and adjust the runtime of the pilot. # NOTE: currently, we assume (near) homogenous runtime among all tasks. task_runtime = workload[0]["runtime"] cores = 0 for task in workload: cores += task["cores"] if cores < maxcpus: pilot_size = cores pilot_runtime = task_runtime else: pilot_size = maxcpus pilot_runtime = task_runtime * (len(workload)/maxcpus) if len(workload)%maxcpus > 0: pilot_runtime += task_runtime print "\n * Number of tasks: %s" % len(workload) print " * Pilot size (# cores): %s" % pilot_size print " * Pilot runtime: %s\n" % pilot_runtime ############################################################ # The pilot description pdesc = radical.pilot.ComputePilotDescription() pdesc.resource = resource pdesc.runtime = pilot_runtime pdesc.cores = pilot_size pdesc.project = allocation pdesc.cleanup = False ############################################################ # Workload definition tasknum = 0 all_tasks = [] # Create CU descriptions from workload taks... for task in workload: tasknum += 1 # Process data handling. idl = task["input_data_location"] if idl.lower() == "here": idl_remote = False elif idl.lower() == "there": idl_remote = True else: print "Unknown 'input_data_location': {0}".format(idl) idl = task["output_data_location"] if idl.lower() == "here": odl_remote = False elif idl.lower() == "there": odl_remote = True else: print "Unknown 'output_data_location': {0}".format(odl) input_nmode = task["input"] nmode_basen = os.path.basename(input_nmode) input_com = task["complex_prmtop"] com_basen = os.path.basename(input_com) input_rec = task["receptor_prmtop"] rec_basen = os.path.basename(input_rec) input_lig = task["ligand_prmtop"] lig_basen = os.path.basename(input_lig) input_traj = task["trajectory"] traj_basen = os.path.basename(input_traj) output = task["output"] mdtd = MDTaskDescription() mdtd.kernel = "MMPBSA" mdtd.arguments = "-i {0} -cp {1} -rp {2} -lp {3} -y {4}".format(nmode_basen, com_basen, rec_basen, lig_basen, traj_basen) if idl_remote is True: mdtd.copy_local_input_data = [input_nmode, input_com, input_rec, input_lig, input_traj] mdtd_bound = mdtd.bind(resource=resource) mmpbsa_task = radical.pilot.ComputeUnitDescription() mmpbsa_task.environment = mdtd_bound.environment mmpbsa_task.pre_exec = mdtd_bound.pre_exec mmpbsa_task.executable = mdtd_bound.executable mmpbsa_task.arguments = mdtd_bound.arguments mmpbsa_task.mpi = mdtd_bound.mpi mmpbsa_task.cores = task["cores"] mmpbsa_task.name = task["name"] if idl_remote is False: # No remote files. All files are local and need to be transferred mmpbsa_task.input_data = [input_nmode, input_com, input_rec, input_lig, input_traj] mmpbsa_task.output_data = ["FINAL_RESULTS_MMPBSA.dat > %s" % output] all_tasks.append(mmpbsa_task) ############################################################ # Call the batch runner br = BatchRunner(config=config) finished_units = br.run(pilot_description=pdesc, cu_descriptions=all_tasks) if type(finished_units) != list: finished_units = [finished_units] print "\nDONE" print "=============================================================================\n" for unit in finished_units: t_start = unit.start_time t_stop = unit.stop_time t_run = t_stop - t_start local_output = unit.description.output_data[0].split(" > ")[1] print " o Task {0} RUNTIME {1} OUTPUT: {2}".format(unit.description.name, t_run, local_output) br.close()