Resource requirement strings

Which sections apply

Simple syntax

select[selection_string] order[order_string] rusage[usage_string [, usage_string]
[|| usage_string] ...] span[span_string] same[same_string] cu[cu_string] affinity[affinity_string]

With the bsub and bmod commands, and only with these commands, you can specify multiple -R order, same, rusage, and select sections. The bmod command does not support the use of the || operator.

The section names are select, order, rusage, span, same, cu, and affinity. Sections that do not apply for a command are ignored.

The square brackets must be typed as shown for each section. A blank space must separate each resource requirement section.

You can omit the select[] section, but if you include it, the selection section must be the first string in the resource requirement string. If you do not use a section keyword (select, order, rusage, span, same, cu, and affinity), the first resource requirement string is treated as a selection string (select[selection_string]).

Each section has a different syntax.

By default, memory (mem) and swap (swp) limits in select[] and rusage[] sections are specified in MB. Use the LSF_UNIT_FOR_LIMITS parameter in the lsf.conf file to specify a larger unit for these limits.

Compound syntax

num1*{simple_string1} + num2*{simple_string2} + ...

where numx is the number of slots that are affected and simple_stringx is a simple resource requirement string with the syntax:

select[selection_string] order[order_string] rusage[usage_string [, usage_string]...] span[span_string]

Resource requirements that apply to the first execution host (if used) appear in the first compound term num1*{simple_string1}.

Place specific (harder to fill) requirements before general (easier to fill) requirements since compound resource requirement terms are considered in the order they appear. Resource allocation for parallel jobs that use compound resources is done for each compound resource term independently instead of considering all possible combinations.

num1*{simple_string1} + 
num2*{simple_string2} + 
num3*{simple_string3}

Compound resource requirements do not support use of the || operator within the component rusage simple resource requirements, or use of the cu section.

Compound queue level

When a compound resource requirement is set for a queue, it is ignored unless it is the only resource requirement specified (no resource requirements are set at the job level or application level).

Compound application level

When a compound resource requirement is set at the application level, it is ignored if any job-level resource requirements (simple or compound) are defined.

If no job-level resource requirements are set, the compound application-level requirements interact with queue-level resource requirement strings in the following ways:

• If no queue-level resource requirement is defined or a compound queue-level resource requirement is defined, the compound application-level requirement is used.
• If a simple queue-level requirement is defined, the application-level and queue-level requirements combine as follows:

  ---

  Section	Compound application and simple queue behavior
  select	Both levels are satisfied. Queue requirement applies to all compound terms.
  same	Queue level is ignored.
  order and span	Application-level section overwrites queue-level section (if a level is present). Queue requirement (if used) applies to all compound terms.
  rusage	Both levels merge. Queue requirement if a job-based resource is applied to the first compound term, otherwise applies to all compound terms. If conflicts occur, the application-level section overwrites the queue-level section. For example, if the application-level requirement is num1*{rusage[R1]} + num2*{rusage[R2]} and the queue-level requirement is rusage[RQ] where RQ is a job-based resource, the merged requirement is num1*{rusage[merge(R1,RQ)]} + num2*{rusage[R2]}

  ---

Compound job level

When a compound resource requirement is set at the job level, any simple or compound application-level resource requirements are ignored, and any compound queue-level resource requirements are ignored.

If a simple queue-level requirement appears with a compound job-level requirement, the requirements interact as follows:

Combined resource requirements

The combined resource requirement is the result of the mbatchd daemon merging job, application, and queue level resource requirements for a job.

Effective resource requirements

The effective resource requirement always represents the job's allocation. The effective resource requirement string for scheduled jobs represents the resource requirement that is used by the scheduler to make a dispatch decision. When a job is dispatched, the mbschd daemon generates the effective resource requirement for the job from the combined resource requirement according to the job's real allocation.

After the job starts, you can use the bmod -R command to modify the job's effective resource requirement along with the job allocation. The rusage section of the effective resource is updated with the rusage in the newly combined resource requirement. The other sections in the resource requirement string such as select, order, and span are kept the same during job run time because they are still used for the job by the scheduler.

For started jobs, you can modify only simple effective resource requirements with another simple requirement. Any request to change effective resource requirements to compound or alternative resource requirements are rejected. Attempting to modify the resource requirement of a running job to use rusage with or (||) branches are also rejected.

By default, LSF does not modify effective resource requirements and job resource usage when it runs the bswitch command. However, you can set the BSWITCH_MODIFY_RUSAGE parameter to Y to make the bswitch command update job resource usage according to the resource requirements in the new queue.

When a job finishes, the effective resource requirement last used by the job is saved in the JOB_FINISH event record of the lsb.acct file and the JOB_FINISH2 record of the lsb.stream file. The bjobs -l command always displays the effective resource requirement that is used by the job in the resource requirement details.