Shared License Buffer (SLB) User Guide
Table of Contents
1.1. The Purpose of the SLB
The Software License Buffer (SLB) regulates shared license usage across all HPC systems by granting and enforcing license reservations for Abaqus, ANSYS, GASP, LS-DYNA, MATLAB, and STAR-CCM+.
A license reservation is granted for a certain number of licenses, for a specific time window, and optionally, for certain licensed features of an application. Licenses cannot be checked out without a license reservation, and batch jobs are started only when a license reservation request has been approved.
The denial of license checkouts without a reservation ensures jobs with a license reservation can checkout licenses throughout the entire period of the reservation.
The SLB grants license reservations for MATLAB, but they are not enforced. While less robust than license reservations that are enforced, this service is nevertheless helpful because it instructs the batch queuing system to withhold a job until the licenses needed are available. However, the batch queuing system cannot guarantee the licenses will still be available when the job tries to check them out. Without license enforcement, there is a small chance 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 the batch queuing system knows not to start the job if too few licenses are currently available. In the future, enforcement for MATLAB 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 the batch queuing system, 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 allows the user to make a license reservation for any time (present or future) without going through the batch queuing system or ARS. The intention is to allow users to reserve licenses for interactive work. This is described in 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. - 8:00 p.m. Eastern, Monday - Friday (excluding Federal holidays).
2. Using the SLB via the Batch Queuing System
To use shared licenses in a batch queuing system job, all you must do is specify which licenses the batch queuing system needs to access. This specification is most easily done in the job script but can be done on the qsub command line using the -l option. After that, you don’t need to do anything else since the batch queuing system and the SLB internally handle the license reservation processing.
Before starting a job, the batch queuing system makes a license reservation request to the SLB based on the licenses you requested and the job's wall-clock time. The SLB determines whether enough licenses are available for the job by considering 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 creates a license reservation for it, and the SLB notifies the batch queuing system it can start the job. If there are not enough licenses to make a reservation for the job, then the SLB tells the batch queuing system it cannot start the job now and the batch queuing system tries again later.
To get the main license for an application, use one of the following for PBS jobs:
#PBS -l abaqus=N
#PBS -l cdf_solve_level1=1
#PBS -l ansys=1
#PBS -l anshpc=N
#PBS -l anshpc_pack=N
#PBS -l gasp=1
#PBS -l lsdyna=N
#PBS -l mppdyna=N
#PBS -l MATLAB=1 (or matlab=1)
#PBS -l ccmppower=1
#PBS -l ccmppowerplus=1
#PBS -l ccmppower_legacy=1
3. Using the SLB Interactively
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, run the utility SLB_make_resv.pl and specify the application, number of licenses and time window. The SLB determines whether the requested number of licenses is available throughout the specified time window. If so, the license reservation request is approved, and you are notified that you have a license reservation. If the SLB determines an insufficient number of licenses are available, the SLB denies the license request and notifies you. The user may then make a different request for either fewer licenses or for a different time window.
If you want to obtain some information on license availability beforehand to make a more informed reservation request (such as through ARS), you can run SLB queries 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 a reservation is not made; instead, the SLB merely informs the user as to whether 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 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 mustang -user username -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_job_resv.pl||Display job license reservations||SLB_disp_job_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 cfd_solve_level1|
|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 cfd_solve_level1|
|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 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 month/day_hour:minute format:
-st MM/DD_HH:mm -et MM/DD_HH:mm
The start and end times can be specified in epoch time (the time lapse in
seconds since Jan. 1, 1970):
-ts epoch_start -te epoch_end
The start time can be specified as -st MM/DD_HH:mm, and the duration can
be specified in hours:
-st MM/DD_HH:mm -dur hours
The start time can be specified in epoch time, and the duration can
be specified in hours:
-ts epoch_start -dur hours
The following section describes the commands in Table 1 above.
Use SLB_make_resv.pl to request a license reservation. The user is notified if the request is granted or denied. If granted, the reservation ID is displayed.
Required inputs include application -app app and number of licenses: -nlic N or -tok "feature1=N feature2=M". 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 is 120 (2 hours).
Unless the default time window of two (2) hours is desired, the time window must be specified. Users should specify the user with -user username, but if omitted the script attempts to identify the user.
The following is an example of how to use SLB_make_resv.pl:
SLB_make_resv.pl -app matlab -nlic 1 -host narwhal -user username -st 02/09_08:45 -et 02/09_16:00
After making a reservation, a user should run SLB_disp_resv.pl to ensure the reservation is correct. If not, cancel any faulty reservation by running SLB_term_resv.pl and remake the reservation with SLB_make_resv.pl.
This script terminates a reservation. If a reservation is not terminated explicitly (i.e., by calling SLB_term_resv.pl or by the batch queuing system job ending), the reservation expires at the end of its reservation window. However, by calling SLB_term_resv.pl, a reservation is terminated immediately, freeing up the licenses in it. The two required inputs for 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 by running SLB_disp_resv.pl.
This script displays license reservations. It first shows the time window displaying reservations and then displays the reservations per application in chronological 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 (the batch queuing system, ARS, or interactive), or just one application.
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=job, ARS, or interactive), then it may be specified using -type J, -type A, or -type I. "J" is used for "job" reservations. If no type is specified, reservations of all three types are shown.
If the user specifies an application (e.g.,, via -app abaqus), the SLB returns the license reservations for that application. If the user does not specify an application, reservations for all applications are shown.
This script displays ARS reservations for all applications. Its time window starts at the present and has a 365-day duration.
This script displays batch job reservations for all applications. Its time window starts at the present and has a 365-day duration.
This script displays interactive reservations for all applications. Its time window starts at the present (by default, but can be specified as later) 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 the requestable licenses. A requestable licensed feature is one that when requested prompts the batch queuing system to throttle the job until license is available. There is no guarantee of availability and no capability to reserve the license 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 generates 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 -st and -et, or -ts and -te. If not specified, the time period defaults to a window starting at the present and lasting 4 hours.
This script queries the number of licenses available at a given time. The time is specifiable as described above using -st or -ts. If not specified, the time defaults to the present time. The output shows not only how many licenses are available at the specified time, but how long after that they will remain available.
This script works virtually identically to SLB_make_resv.pl (described above), except it does not make a reservation. A user does not need to specify username 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 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*N^(0.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 for N (-ncpu N) or a range N1->N2 (-ncpu1 N1 -ncpu2 N2).
4. Licensed Features
The SLB controls the licenses of some (but not all) licensed features. The advantage of the SLB controlling licenses for a feature is 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. If there are so many licenses 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 making a reservation, but accomplishes nothing since the licenses would rarely 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|
|ANSYS_CFD||cfd_solve_level1||ansys anshpc anshpc_pack|
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 cfd_solve_level1, ansys, anshpc, and anshpc_pack. A parallel job running on N cores requires one cfd_solve_level1 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|