Shared License Buffer (SLB) User Guide
Table of Contents
1.1. The Purpose of the SLB
The Shared License Buffer (SLB) regulates shared license usage across all HPC systems by granting and enforcing license reservations for Abaqus, ANSYS CFD, Cobalt, GASP, LS-DYNA, and STAR-CCM+.
A license reservation will be granted for a certain number of licenses, for a specific time window, and optionally, for certain licensed features of that application. Licenses cannot be checked out without a license reservation, and PBS jobs will be started only when a license reservation request has been approved.
Since licenses cannot be checked out without a reservation, users and jobs that do have a license reservation will be assured of getting their licenses throughout the entire period of their reservation.
The SLB also grants license reservations for MATLAB and Accelrys, but they are not enforced. While less robust than license reservations that are enforced, this service is nevertheless helpful because it instructs PBS to withhold a job until the licenses needed by it are available. However, PBS cannot guarantee that the licenses will still be available a few minutes later when the job actually tries to check them out. Without license enforcement there is a small chance that a job that did not request a reservation will win the race condition and acquire the licenses first. Regardless, a user is better off requesting an SLB license reservation since PBS will then know not to start the job if too few licenses are currently available. In the future, enforcement for MATLAB and/or Accelrys may be enabled based upon which policy is considered most helpful to users.
Users may access the SLB for license reservations in three ways:
- Via PBS, by designating the needed licenses in the job script
- Via the Advance Reservation System (ARS)
- Interactively by running an SLB script on any HPC system
This last option is new and allows the user to make a license reservation for any time (present or future) without going through PBS or ARS. The intention is to allow users to reserve licenses for interactive work. This is described in detail later.
Another enhancement to the SLB is the capability to reserve licensed features, which is also described in further detail later.
1.2. Requesting Assistance
The HPC Help Desk is available to help users with unclassified problems, issues, or questions. Analysts are on duty 8:00 a.m - 11:00 p.m. Eastern, Monday - Friday (excluding Federal holidays).
2. Using the SLB via PBS
To use shared licenses in a PBS job, all the user has to do is specify which
licenses PBS needs to access. This specification is most easily done in the job
script, but can be done on the qsub command line using the
option. After doing that, the user does not need to do anything else since PBS
and the SLB will internally handle the license reservation processing.
Before starting a job, PBS will make a license reservation request to the SLB based on the licenses the user requested and the job's wall-clock time. The SLB will determine whether or not enough licenses are available for the job by taking into account the job's time window (the time window is basically from the current time until the current time plus the job's wall-clock time), the number of licenses requested for the job, and all existing license reservations for the application. If sufficient licenses are available for the time window of the job, the SLB will create a license reservation for it, and the SLB will notify PBS that it can start the job. If there are not enough licenses to make a reservation for the job, then the SLB will tell PBS that it cannot start the job now and PBS will try again later.
To get the main license for an application, use one of the following:
#PBS -l abaqus=N #PBS -l acfd_solver=1 #PBS -l MSI_TokenR=N #PBS -l MS_castep_MP=1 #PBS -l MATLAB=1 #PBS -l gasp=1 #PBS -l ccmppower=1 (or equivalently: #PBS -l starccm=1) #PBS -l lsdyna=N
Here are samples of how to get licensed features:
#PBS -l acfd_solver=1,anshpc=N #PBS -l MS_gulp=N #PBS -l MATLAB=1,MATLAB_Distrib_Comp_Engine=N #PBS -l mppdyna=N
3. Using the SLB Interactively
The SLB offers a suite of scripts ("SLB utilities") that users can interactively run to make a license reservation or cancel a reservation.
There are SLB utilities that display license reservations, display licensed features (controlled by the SLB or not), display all "reservable" features (i.e., only those that are controlled by the SLB), or obtain information about license availability.
To make a reservation interactively, a user runs the utility
SLB_make_resv.pl and specifies the application, number of licenses
and time window. The SLB will determine whether or not the requested number of
licenses is available throughout the specified time window. If so, the license
reservation request is approved and the user is notified that he/she has a
license reservation. If the SLB determines that an insufficient number of
licenses are available throughout the time window, the SLB will deny the
license request and notify the user. The user may then make a different request,
for either fewer licenses or for a different time window. The user may also
reserve any licensed features that are controlled by the SLB.
If the user wants to obtain some information on license availability beforehand to make a more informed reservation request (such as through ARS), he or she can run SLB utilities to answer the following questions:
- How many licenses are available now?
- When will N licenses be available?
- How many licenses will be available at a given time?
- How many licenses will be available throughout a certain time window?
- Could a reservation for N licenses be made for a certain time window?
The last query is the same as making a reservation request except that a reservation is not made; instead, the SLB merely informs the user as to whether or not the request would have been approved or denied. And as mentioned earlier, the user can run a utility to display all reservations. All of these queries inform the users about license availability so that they may make the best license reservation(s) appropriate for their needs.
3.1. Command Line Scripts
Using the SLB interactively via the command line interface is a simple matter of picking the appropriate script and running it with the correct arguments. Some arguments are optional, some are required, and some have defaults. If a script is run with a required argument missing, it will output a "usage" message prompting the user to supply the needed argument.
The command line interface consists of the set of scripts shown below, which are available on the HPC systems. Additional information about each of the commands can be found in the sections following the chart.
|SLB_make_resv.pl||Make a license reservation||SLB_make_resv.pl -app matlab -nlic 1-host hawk -user thompson -st 02/09_08:45 -et 02/09_16:00|
|SLB_term_resv.pl||Terminate a license reservation||SLB_term_resv.pl -app matlab -id I54321|
|SLB_all_avail.pl||Display licenses currently available||SLB_all_avail.pl abaqus|
|SLB_disp_all_resv.pl||Display all license reservations||SLB_disp_all_resv.pl -app matlab|
|SLB_disp_ARS_resv.pl||Display ARS license reservations||SLB_disp_ARS_resv.pl|
|SLB_disp_PBS_resv.pl||Display PBS license reservations||SLB_disp_PBS_resv.pl|
|SLB_disp_inter_resv.pl||Display interactive license reservations||SLB_disp_inter_resv.pl|
|SLB_disp_licensed_features.pl||Display reservable and requestable features||SLB_disp_licensed_features.pl abaqus|
|SLB_disp_reservable_features.pl||Display reservable features||SLB_disp_reservable_features.pl|
|SLB_query_avail_block.pl||Query number of licenses avail in time window||SLB_query_avail_block.pl -app acfd -st 12/23_08:00 -et 12/26_15:00 -tok acfd_solver|
|SLB_query_avail_t.pl||Query number of licenses avail at time "t"||SLB_query_avail_t.pl -app acfd -st 12/23_08:00 -tok acfd_solver|
|SLB_query_resv.pl||Query a reservation||SLB_query_resv.pl -app acfd -nlic 1 -st 02/09_06:40 -et 02/09_11:00|
|SLB_query_when.pl||Query when N licenses will be available||SLB_query_when.pl -app acfd -tok anshpc=128|
|SLB_abaqus_map.pl||Compute number of Abaqus licenses needed||SLB_abaqus_map.pl -ncpu1 78 -ncpu2 104|
Several of the scripts above have a "time window," for either making a license reservation, querying about license availability, or displaying license reservations. Each of these scripts has a default time window, but allows specification of an arbitrary time window using input arguments. A time window can be specified in any of the four following ways:
- The start and end times can be specified in epoch time (where epoch time is
the time lapse in seconds since Jan. 1, 1970) as:
-ts epoch_start -te epoch_end
- The start and end times can be specified in month/day_hour:minute format
-st MM/DD_HH:mm -et MM/DD_HH:mm
- The start time can be specified in epoch time as in (1) and the duration can
be specified in hours as
-ts epoch_start -dur hours
- The start time can be specified as -st MM/DD_HH:mm as in (2) and the
duration can be specified in hours as
-st MM/DD_HH:mm -dur hours
The following section will describe the commands in Table 1 above.
SLB_make_resv.pl to request a license reservation (by policy,
currently applies only to MATLAB). If the SLB approves the reservation, it will
be created. Furthermore, if the reservation is to begin within 30 seconds, this
script will activate the reservation before returning. Activation is the process
in which the SLB directs the license manager to reserve licenses for the user. If
the reservation starts more than 30 seconds into the future, the script returns
immediately, as opposed to waiting for activation. In this case, activation of
the interactive reservation is automatic, just as ARS reservations are.
Required inputs include application
-app app and number of
-nlic N. A time window is also needed, and can be
specified as described above with two exceptions:
(1) the duration is specified in minutes and
(2) the duration default for MATLAB is 120 (=2 hours).
Unless the default time window of 2 hours is desired, the time window must be specified. Users should specify the user with
-user user_name, but if omitted the script will attempt
to identify the user. Licensed features may be reserved by:
-tok "feat1=N feat2=M .".
The following is an example of how to use
SLB_make_resv.pl -app matlab -nlic 1 -host hawk -user thompson -st 02/09_08:45 -et 02/09_16:00
After making a reservation, a user should run
to ensure that the reservation is correct. If not, cancel any faulty reservation
SLB_term_resv.pl and remake the reservation with
This script terminates a reservation. If a reservation is not terminated
explicitly (i.e., by calling
SLB_term_resv.pl or by a PBS job
ending), the reservation will expire at the end of its reservation window.
However, by calling
SLB_term_resv.pl, a reservation will be
terminated and the licenses in it will be freed up sooner. The two required
SLB_term_resv.pl are application
-app app and ID
-id ID. The SLB
assigns the ID when the user creates the reservation. The user can find the ID
This script displays license reservations. The script first displays the time window for which it will display reservations, and then displays the reservations per application (in no particular order). The easiest way to run this command is with no arguments, but input arguments can be used to specify the desired time window as described above, the type of reservations displayed (PBS, ARS, or interactive), or the application if desired.
The default time window starts at the present time and has a duration of 365 days.
If only one type of reservation is desired (type=PBS, ARS, or interactive),
then it may be specified using
-type A, or
-type I. "J" is used for PBS "job" reservations. If no type is
specified, reservations of all three types are shown.
If the user specifies an application (for example, via
-app abaqus), the SLB returns the license reservations for
that application. If the user does not specify an application, the default shows
reservations for all applications.
This script displays ARS reservations for all applications. Its time window starts at the present and has a 365-day duration.
This script displays PBS reservations for all applications. Its time window starts at the present and has a 365-day duration.
This script displays PBS reservations for all applications. Its time window starts at the present and has a 365-day duration.
This script shows reservable and requestable licensed features of each SLB application. For an application, it first shows those licensed features that can be reserved, and then those that cannot be reserved through the SLB, but can be requested of PBS. A requestable feature is one that a user can request, and PBS will throttle the job based on the availability of such license, but there is no guarantee of availability and no capability to reserve it in advance. For each feature, the result shows the current number of licenses available. This script optionally accepts one application as an argument. If no argument is given, it will generate output for all supported applications.
This script shows the reservable features of each application and the number of licenses under the control of the SLB, which excludes licenses dedicated for groups or individuals. This script takes no arguments.
This script queries the number of licenses available for a given period (block)
of time. The block of time is specifiable as described above using
If not specified, the time period defaults to a window starting 'now' and
lasting 4 hours.
This script queries the number of licenses available at a given time. The time
is specifiable as described above using
If not specified, the time defaults to 'now'. The output shows not only how many
licenses are available at the specified time, but how long after that they will
This script works virtually identically to
(described above), except it does not make a reservation. A user does not need
to specify user name or host, but all other inputs are like those of
SLB_make_resv.pl. Instead of making a reservation, this script
gives a return code according to whether or not the requested license
reservation could be made at the present time.
This query returns the time at which the specified number of licenses will first be available and how long they will be available.
This utility computes the number of Abaqus licenses needed for an N
core job. The formula it computes is P*N0.422,
where P=3 (for Foundation functionality), P=4 (for Foundation and Design or
Foundation and Direct Coupling Interface), P=5 (for Standard functionality),
or P=6 (for Aqua functionality). This script accepts either a single value
-ncpu N or a range
-ncpu1 N1 -ncpu2 N2.
4. Licensed Features
The new SLB controls the licenses of some (but not all) licensed features. The advantage of the SLB controlling licenses for a feature is that users may reserve the license and be assured of being able to use that feature during the reservation period.
Some licensed features come with a large number of licenses (especially many of the features of Accelrys). If there are so many licenses that we would never run out, then there is no advantage in making the feature reservable. In this case, having the SLB control the licenses to the feature burdens the user with having to make a reservation, but accomplishes nothing since the licenses would never be exhausted. Therefore, certain features are deliberately not controlled by the SLB, which allows users to use them without the need to make a reservation.
4.1. Licenses and Licensed Features
The main application licenses and licensed features controlled by the SLB are as follows:
|Application||Main License||Licensed Features|
4.2. ANSYS CFD (ACFD, formerly Fluent)
Fluent was bought by ANSYS and ANSYS changed Fluent to ACFD (Ansys CFD), and
thus all Fluent licenses (fluent, fluentall, fluent_par, etc.) are obsolete. The
new licenses are named
parallel job running on N cores requires one
license and N
anshpc licenses. The geographical pools used
for Fluent licenses no longer apply.
Ansys pack licenses, labeled as anshpc_pack, allow for greatly expanded Ansys job core usage when paired with Ansys CFX or multiphysics solvers. The Ansys pack licenses have a multiplier effect, wherein the Pack licenses scale by 4X cores per each Pack applied to an Ansys solve. Due to this scaling effect, Pack license usage is not viable below four (4) Packs, so no jobs should be run requesting fewer than four (4) Pack licenses.
Please refer to the table below to clarify how many Ansys Packs are required for specific job core counts:
|HPC Packs||HPC Pack Cores||Solver Cores||Total Cores|
If a user requests licenses for
MS_visualizer and not enough are available, the SLB will substitute
MSI_TokenR licenses, if they are available.
LS-DYNA users must reserve
mppdyna for the MPPDYNA functionality
lsdyna for LSDYNA functionality.
By policy, a user is limited to one
ccmppower license at a time