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
