def prepareBsub(cpu, mem, jobID): """ Make a bsub commandline to execute. params: cpu: number of cores needed mem: number of bytes of memory needed jobID: ID number of the job """ if mem: if per_core_reservation(): mem = float(mem)/1024**3/math.ceil(cpu) mem_resource = parse_memory_resource(mem) mem_limit = parse_memory_limit(mem) else: mem = old_div(float(mem), 1024**3) mem_resource = parse_memory_resource(mem) mem_limit = parse_memory_limit(mem) bsubMem = ['-R', 'select[type==X86_64 && mem > {m}] ' 'rusage[mem={m}]'.format(m=mem_resource), '-M', str(mem_limit)] else: bsubMem = [] bsubCpu = [] if cpu is None else ['-n', str(math.ceil(cpu))] bsubline = ["bsub", "-cwd", ".", "-o", "/dev/null", "-e", "/dev/null", "-J", "toil_job_{}".format(jobID)] bsubline.extend(bsubMem) bsubline.extend(bsubCpu) lsfArgs = os.getenv('TOIL_LSF_ARGS') if lsfArgs: bsubline.extend(lsfArgs.split()) return bsubline
def prepareBsub(self, cpu, mem, jobID): """ Make a bsub commandline to execute. params: cpu: number of cores needed mem: number of bytes of memory needed jobID: ID number of the job """ bsubMem = [] if mem: mem = float(mem) / 1024**3 if per_core_reservation() and cpu: mem = mem / math.ceil(cpu) mem_resource = parse_memory_resource(mem) mem_limit = parse_memory_limit(mem) bsubMem = [ '-R', f'select[mem>{mem_resource}] ' f'rusage[mem={mem_resource}]', '-M', mem_limit ] bsubCpu = [] if cpu is None else ['-n', str(math.ceil(cpu))] bsubline = ["bsub", "-cwd", ".", "-J", f"toil_job_{jobID}"] bsubline.extend(bsubMem) bsubline.extend(bsubCpu) stdoutfile = self.boss.formatStdOutErrPath(jobID, 'lsf', '%J', 'std_output') stderrfile = self.boss.formatStdOutErrPath(jobID, 'lsf', '%J', 'std_error') bsubline.extend(['-o', stdoutfile, '-e', stderrfile]) lsfArgs = os.getenv('TOIL_LSF_ARGS') if lsfArgs: bsubline.extend(lsfArgs.split()) return bsubline
def test_custom_lsf_per_core_env(tmpdir): jobstore = tmpdir.join("jobstore").strpath log = tmpdir.join("log.txt").strpath options = parsers.ToilBaseArgumentParser().parse_args( [jobstore, "--logFile", log]) options.batchSystem = "custom_lsf" options.disableCaching = True # Set total memory per job os.environ["TOIL_CONTAINER_LSF_PER_CORE"] = "N" job_1 = jobs.ContainerJob(options, runtime=1, cores=2, memory="10G") jobs.ContainerJob.Runner.startToil(job_1, options) with open(log, "rt", encoding="utf-8") as f: assert "-M 10000MB -n 2" in f.read() # Set total memory per core os.environ["TOIL_CONTAINER_LSF_PER_CORE"] = "Y" job_2 = jobs.ContainerJob(options, runtime=1, cores=2, memory="10G") jobs.ContainerJob.Runner.startToil(job_2, options) with open(log, "rt", encoding="utf-8") as f: assert "-M 5000MB -n 2" in f.read() # Use per_core_reservation() from lsf config del os.environ["TOIL_CONTAINER_LSF_PER_CORE"] job_3 = jobs.ContainerJob(options, runtime=1, cores=2, memory="10G") jobs.ContainerJob.Runner.startToil(job_3, options) with open(log, "rt", encoding="utf-8") as f: assert ("-M 5000MB -n 2" if per_core_reservation() else "-M 10000MB -n 2") in f.read()
def prepareBsub(cpu, mem): """ Make a bsub commandline to execute. params: cpu: number of cores needed mem: number of bytes of memory needed """ if mem: if per_core_reservation(): mem = float(mem) / 1024**3 / int(cpu) mem_resource = parse_memory_resource(mem) mem_limit = parse_memory_limit(mem) else: mem = old_div(float(mem), 1024**3) mem_resource = parse_memory_resource(mem) mem_limit = parse_memory_limit(mem) bsubMem = '-R "select[type==X86_64 && mem > ' + str(mem_resource) + '] '\ 'rusage[mem=' + str(mem_resource) + ']" -M' + str(mem_limit) else: bsubMem = '' cpuStr = '' if cpu is None else '-n ' + str(int(cpu)) bsubline = [ "bsub", bsubMem, cpuStr, "-cwd", ".", "-o", "/dev/null", "-e", "/dev/null" ] lsfArgs = os.getenv('TOIL_LSF_ARGS') if lsfArgs: bsubline.extend(lsfArgs.split()) return bsubline
def build_bsub_line(cpu, mem, runtime, jobname, stdoutfile=None, stderrfile=None): """ Build an args list for a bsub submission. Arguments: cpu (int): number of cores needed. mem (float): number of bytes of memory needed. runtime (int): estimated run time for the job in minutes. jobname (str): the job name. stdoutfile (str): filename to direct job stdout stderrfile (str): filename to direct job stderr Returns: list: bsub command. """ bsubline = [ "bsub", "-cwd", ".", "-o", stdoutfile or "/dev/null", "-e", stderrfile or "/dev/null", "-J", f"'{jobname}'", ] cpu = int(cpu) or 1 if mem: per_core = os.getenv("TOIL_CONTAINER_LSF_PER_CORE") if (per_core == "Y") or (not per_core and per_core_reservation()): mem = mem / cpu mem_resource = _parse_memory(mem) mem_limit = _parse_memory(mem) bsubline += ["-R", f"select[mem>{mem_resource}]"] bsubline += ["-R", f"rusage[mem={mem_resource}]"] bsubline += ["-M", str(mem_limit)] if cpu: bsubline += ["-n", str(cpu)] if runtime: bsubline += [ os.getenv("TOIL_CONTAINER_RUNTIME_FLAG", "-W"), str(int(runtime)) ] if os.getenv("TOIL_LSF_ARGS"): bsubline.extend(os.getenv("TOIL_LSF_ARGS").split()) # log to lsf logger.info("Submitting to LSF with: %s", " ".join(bsubline)) return bsubline
def build_bsub_line(cpu, mem, runtime, jobname): """ Build an args list for a bsub submission. Arguments: cpu (int): number of cores needed. mem (float): number of bytes of memory needed. runtime (int): estimated run time for the job in minutes. jobname (str): the job name. Returns: list: bsub command. """ unique = lambda i: sorted(set(map(str, i))) rusage = [] select = [] bsubline = [ "bsub", "-cwd", ".", "-o", "/dev/null", "-e", "/dev/null", "-J", "'{}'".format(jobname), ] if mem: if os.getenv(_PER_SLOT_LSF_CONFIG) == "Y" or per_core_reservation(): mem = float(mem) / 1024 ** 3 / int(cpu) else: mem = old_div(float(mem), 1024 ** 3) mem = mem if mem >= 1 else 1.0 mem_resource = parse_memory_resource(mem) mem_limit = parse_memory_limit(mem) select.append("mem > {}".format(mem_resource)) rusage.append("mem={}".format(mem_resource)) bsubline += ["-M", str(mem_limit)] if cpu: bsubline += ["-n", str(int(cpu))] if runtime: bsubline += [os.getenv("TOIL_CONTAINER_RUNTIME_FLAG", "-W"), str(int(runtime))] if select: bsubline += ["-R", "select[%s]" % " && ".join(unique(select))] if rusage: bsubline += ["-R", "rusage[%s]" % " && ".join(unique(rusage))] if os.getenv("TOIL_LSF_ARGS"): bsubline.extend(os.getenv("TOIL_LSF_ARGS").split()) # log to lsf logger.info("Submitting to LSF with: %s", " ".join(bsubline)) return bsubline
def test_build_bsub_line(): os.environ["TOIL_LSF_ARGS"] = "-q test" mem = 2147483648 cpu = 1 obtained = lsf.build_bsub_line(cpu=cpu, mem=mem, runtime=1, jobname="Test Job") if per_core_reservation(): mem = float(mem) / 1024**3 / int(cpu or 1) else: mem = old_div(float(mem), 1024**3) mem_resource = parse_memory_resource(mem) mem_limit = parse_memory_limit(mem) expected = [ "bsub", "-cwd", ".", "-o", "/dev/null", "-e", "/dev/null", "-J", "'Test Job'", "-M", str(mem_limit), "-n", "1", "-W", "1", "-R", "select[mem > {0}]".format(mem_resource), "-R", "rusage[mem={0}]".format(mem_resource), "-q", "test", ] assert obtained == expected del os.environ["TOIL_LSF_ARGS"]
def prepareBsub(cpu, mem): """ Make a bsub commandline to execute. params: cpu: number of cores needed mem: number of bytes of memory needed """ if mem: if per_core_reservation(): mem = parse_memory(float(mem)/1024**3/int(cpu)) else: mem = parse_memory(old_div(float(mem),1024**3)) bsubMem = '-R "select[type==X86_64 && mem > ' + str(mem) + '] '\ 'rusage[mem=' + str(mem) + ']" -M' + str(mem) else: bsubMem = '' cpuStr = '' if cpu is None else '-n ' + str(int(cpu)) bsubline = ["bsub", bsubMem, cpuStr,"-cwd", ".", "-o", "/dev/null", "-e", "/dev/null"] lsfArgs = os.getenv('TOIL_LSF_ARGS') if lsfArgs: bsubline.extend(lsfArgs.split()) return bsubline