Knowledge Center         Contents    Previous  Next    
Platform Computing Corp.

lsb_parameterinfo()

Returns information about the LSF cluster.

DESCRIPTION

lsb_parameterinfo() gets information about the LSF cluster.

The static storage for the parameterInfo structure is reused on the next call.

SYNOPSIS

#include <lsf/lsbatch.h> 
struct parameterInfo *lsb_parameterinfo(char **names,  
                      int *numUsers, int options) 
struct parameterInfo { 
    char *defaultQueues;  
    char *defaultHostSpec;  
    int  mbatchdInterval;  
    int  sbatchdInterval;  
    int  jobAcceptInterval; 
    int  maxDispRetries; 
    int  maxSbdRetries;  
    int  preemptPeriod;  
    int  cleanPeriod;  
    int  maxNumJobs;  
    float historyHours;  
    int  pgSuspendIt;  
    char *defaultProject;  
    int  retryIntvl; 
    int  nqsQueuesFlags; 
    int  nqsRequestsFlags; 
    int  maxPreExecRetry; 
    int  eventWatchTime; 
    float runTimeFactor; 
    float waitTimeFactor; 
    float runJobFactor; 
    int  eEventCheckIntvl; 
    int  rusageUpdateRate; 
    int  rusageUpdatePercent; 
    int  condCheckTime; 
    int  maxSbdConnections; 
    int  rschedInterval; 
    int  maxSchedStay;  
    int  freshPeriod; 
    int  preemptFor; 
    int  adminSuspend;  
    int  userReservation;  
    float cpuTimeFactor; 
    int fyStart; 
    int     maxJobArraySize; 
    time_t  exceptReplayPeriod; 
    int jobTerminateInterval;  
    int disableUAcctMap; 
    int enforceFSProj; 
    int enforceProjCheck;  
    int     jobRunTimes; 
    int     dbDefaultIntval; 
    int     dbHjobCountIntval; 
    int     dbQjobCountIntval; 
    int     dbUjobCountIntval; 
    int     dbJobResUsageIntval; 
    int     dbLoadIntval; 
    int     dbJobInfoIntval; 
    int     jobDepLastSub; 
    int     maxJobNameDep; 
    char   *dbSelectLoad; 
    int     jobSynJgrp;  
    char   *pjobSpoolDir;  
    int     maxUserPriority;  
    int     jobPriorityValue;  
    int     jobPriorityTime;  
    int     enableAutoAdjust;  
    int     autoAdjustAtNumPend; 
    float   autoAdjustAtPercent;  
    int     sharedResourceUpdFactor; 
    int     scheRawLoad;  
    char   *jobAttaDir;	  
    int     maxJobMsgNum;  
    int     maxJobAttaSize;  
    int     mbdRefreshTime;  
    int     updJobRusageInterval;  
    char    *sysMapAcct;				 
    int     preExecDelay;  
    int     updEventUpdateInterval;  
    int     resourceReservePerSlot;  
    int	    maxJobId;  
    char    *preemptResourceList;  
    int     preemptionWaitTime;  
    int     maxAcctArchiveNum; 
    int     acctArchiveInDays;  
    int     acctArchiveInSize;  
    float committedRunTimeFactor; 
    int  enableHistRunTime; 
#ifdef PS_SXNQS 
    int   nqsUpdateInterval; 
#endif 
    int  mcbOlmReclaimTimeDelay;  
    int  chunkJobDuration;  
    int  sessionInterval; 
    int  publishReasonJobNum;  
    int  publishReasonInterval;  
    int  publishReason4AllJobInterval; 
    int  mcUpdPendingReasonInterval;  
    int  mcUpdPendingReasonPkgSize; 
    int noPreemptRunTime;  
    int noPreemptFinishTime;  
    char *  acctArchiveAt;  
    int  absoluteRunLimit;  
    int  lsbExitRateDuration;  
    int  lsbTriggerDuration;  
    int  maxJobinfoQueryPeriod; 
    int jobSubRetryInterval;  
    int pendingJobThreshold;  
    int maxConcurrentJobQuery;  
    int minSwitchPeriod;  
    int condensePendingReasons;  
    int slotBasedParallelSched;  
    int disableUserJobMovement;  
    int detectIdleJobAfter;  
    int useSymbolPriority; 
    int JobPriorityRound; 
    char* priorityMapping; 
    int maxInfoDirs;  
    int minMbdRefreshTime;  
    int enableStopAskingLicenses2LS; 
	int expiredTime; 
    char* mbdQueryCPUs;  
    char *defaultApp;  
    int  enableStream;  
    char *streamFile; 
    int  streamSize;  
    int syncUpHostStatusWithLIM;  
    char   *defaultSLA;  
    int    slaTimer;  
     int    mbdEgoTtl;  
    int    mbdEgoConnTimeout;  
    int    mbdEgoReadTimeout;  
    int    mbdUseEgoMXJ;  
    int    mbdEgoReclaimByQueue; 
    int    defaultSLAvelocity;  
    char  *exitRateTypes; 
    float  globalJobExitRate;  
    int    enableJobExitRatePerSlot;  
    int  enableMetric;  
    int  schMetricsSample; 
    float maxApsValue;  
    int  newjobRefresh;  
    int  preemptJobType;  
    char *defaultJgrp;  
    int    jobRunlimitRatio; 
    int    jobIncludePostproc; 
    int    jobPostprocTimeout; 
    int    sschedUpdateSummaryInterval; 
    int    sschedUpdateSummaryByTask; 
    int    sschedRequeueLimit; 
    int    sschedRetryLimit; 
    int    sschedMaxTasks; 
    int    sschedMaxRuntime; 
    char *sschedAcctDir; 
    int     jgrpAutoDel;      
    int     maxJobPreempt; 
    int     maxJobRequeue; 
    int     noPreemptRunTimePercent; 
    int     maxStreamFileNum; 
    int     PrivilegedUserForceBkill; 
    int     intersectCandidateHosts; 
    int     enforceOneUGLimit; 
    int     logRuntimeESTExceeded; 
    char*   computeUnitTypes; 
    float   fairAdjustFactor; 
    int     noPreemptFinishTimePercent; 
    int     slotReserveQueueLimit; 
    int     maxJobPercentagePerSession; 
    int     useSuspSlots; 
}; 

PARAMETERS

**names

Reserved but not used; supply NULL.

*numUsers

Reserved but not used; supply NULL.

options

Reserved but not used; supply 0.

parameterInfo structure

The parameterInfo structure contains the following fields:

defaultQueues

DEFAULT_QUEUE: A blank_separated list of queue names for automatic queue selection.

defaultHostSpec

DEFAULT_HOST_SPEC: The host name or host model name used as the system default for scaling CPULIMIT and RUNLIMIT.

mbatchdInterval

MBD_SLEEP_TIME: The interval in seconds at which the mbatchd dispatches jobs.

sbatchdInterval

SBD_SLEEP_TIME: The interval in seconds at which the sbatchd suspends or resumes jobs.

jobAcceptInterval

JOB_ACCEPT_INTERVAL: The interval at which a host accepts two successive jobs. (In units of SBD_SLEEP_TIME.)

maxDispRetries

MAX_RETRY: The maximum number of retries for dispatching a job.

maxSbdRetries

MAX_SBD_FAIL: The maximum number of retries for reaching an sbatchd.

preemptPeriod

PREEM_PERIOD: The interval in seconds for preempting jobs running on the same host.

cleanPeriod

CLEAN_PERIOD: The interval in seconds during which finished jobs are kept in core.

maxNumJobs

MAX_JOB_NUM: The maximum number of finished jobs that are logged in the current event file.

historyHours

HIST_HOURS: The number of hours of resource consumption history used for fair share scheduling and scheduling within a host partition.

pgSuspendIt

PG_SUSP_IT: The interval a host must be idle before resuming a job suspended for excessive paging.

defaultProject

The default project assigned to jobs.

retryIntvl

Job submission retry interval

nqsQueuesFlags

For Cray NQS compatiblilty only. Used by LSF to get the NQS queue information

maxPreExecRetry

The maximum number of times to attempt the preexecution command of a job from a remote cluster ( MultiCluster only)

eventWatchTime

Event watching Interval in seconds

runTimeFactor

Run time weighting factor for fairshare scheduling

waitTimeFactor

used for calcultion of the fairshare scheduling formula

runJobFactor

Job slots weighting factor for fairshare scheduling

eEventCheckIntvl

default check interval

rusageUpdateRate

sbatchd report every sbd_sleep_time

rusageUpdatePercent

sbatchd updates jobs jRusage in mbatchd if more than 10% changes

condCheckTime

time period to check for reconfig

maxSbdConnections

The maximum number of connections between master and slave batch daemons

rschedInterval

The interval for rescheduling jobs

maxSchedStay

Max time mbd stays in scheduling routine, after which take a breather

freshPeriod

During which load remains fresh

preemptFor

The preemption behavior, GROUP_MAX, GROUP_JLP, USER_JLP, HOST_JLU, MINI_JOB, LEAST_RUN_TIME

adminSuspend

Flags whether users can resume their jobs when suspended by the LSF administrator

userReservation

Flags to enable/disable normal user to create advance reservation

cpuTimeFactor

CPU time weighting factor for fairshare scheduling

fyStart

The starting month for a fiscal year

maxJobArraySize

The maximum number of jobs in a job array

exceptReplayPeriod

Replay period for exceptions, in seconds

jobTerminateInterval

The interval to terminate a job

disableUAcctMap

User level account mapping for remote jobs is disabled

enforceFSProj

If set to TRUE, Project name for a job will be considerred when doing fairshare scheduling, i.e., as if user has submitted jobs using -G

enforceProjCheck

Enforces the check to see if the invoker of bsub is in the specifed group when the -P option is used

jobRunTimes

Run time for a job

dbDefaultIntval

Event table Job default interval

dbHjobCountIntval

Event table Job Host Count

dbQjobCountIntval

Event table Job Queue Count

dbUjobCountIntval

Event table Job User Count

dbJobResUsageIntval

Event table Job Resource Interval

dbLoadIntval

Event table Resource Load Interval

dbJobInfoIntval

Event table Job Info

jobDepLastSub

Used with job dependency scheduling

maxJobNameDep

Used with job dependency scheduling, deprecated

dbSelectLoad

select resources to be logged

jobSynJgrp

job synchronizes its group status

pjobSpoolDir

The batch jobs' temporary output directory

maxUserPriority

Maximal job priority defined for all users

jobPriorityValue

Job priority is increased by the system dynamically based on waiting time

jobPriorityTime

Waiting time to increase Job priority by the system dynamically

enableAutoAdjust

Enable internal statistical adjustment

autoAdjustAtNumPend

Start to autoadjust when the user has this number of pending jobs

autoAdjustAtPercent

If this number of jobs has been visited skip the user

sharedResourceUpdFactor

Static shared resource update interval for the cluster

scheRawLoad

schedule job based on raw load info

jobAttaDir

The batch jobs' external storage for attached data

maxJobMsgNum

Maximum message number for each job

maxJobAttaSize

Maximum attached data size to be transferred for each message

mbdRefreshTime

The life time of a child MBD to serve queries in the MT way

updJobRusageInterval

The interval of the execution cluster updating the job's resource usage

sysMapAcct

The account to which all windows workgroup users are to be mapped

preExecDelay

dispatch delay internal

updEventUpdateInterval

The interval of updating duplicated logging info

resourceReservePerSlot

Resources are reserved for parallel jobs on a per-slot basis

maxJobId

The Maximum JobId defined in the system

preemptResourceList

The list of preemption resources

preemptionWaitTime

The time for preemption wait

maxAcctArchiveNum

Max number of Acct files

acctArchiveInDays

Mbatchd Archive Interval

acctArchiveInSize

Mbatchd Archive threshold

committedRunTimeFactor

Committed run time weighting factor

enableHistRunTime

Enable the use of historical run time in the calculation of fairshare scheduling priority, Disable the use of historical run time in the calculation of fairshare scheduling priority

nqsUpdateInterval

NQS resource usage update interval

mcbOlmReclaimTimeDelay

Open lease reclaim time

chunkJobDuration

Enable chunk job dispatch for jobs with CPU limit or run limits

sessionInterval

The interval for scheduling jobs by scheduler daemon

publishReasonJobNum

The number of jobs per user per queue whose pending reason is published at the PEND_REASON_UPDATE_INTERVAL interval

publishReasonInterval

The interval for publishing job pending reason by scheduler daemon

publishReason4AllJobInterval

Interval (in seconds) of pending reason publish for all jobs

mcUpdPendingReasonInterval

MC pending reason update interval (0 means no updates)

mcUpdPendingReasonPkgSize

MC pending reason update package size (0 means no limit)

noPreemptRunTime

No preemption run time

noPreemptFinishTime

No preemption finish time

acctArchiveAt

Mbatchd Archive Time

absoluteRunLimit

Absolute run limit for job

lsbExitRateDuration

The job exit rate duration

lsbTriggerDuration

The duration to trigger eadmin

maxJobinfoQueryPeriod

Maximum time for job information query commands (for example,with bjobs) to wait

jobSubRetryInterval

Job submission retry interval

pendingJobThreshold

System wide max pending jobs

maxConcurrentJobQuery

Maximum concurrent job query

minSwitchPeriod

Minimal event switch period

condensePendingReasons

Condense pending reasons enabled

slotBasedParallelSched

Schedule Parallel jobs based on slots instead of CPUs

disableUserJobMovement

Job position control by admin

detectIdleJobAfter

Detect idle jobs after

useSymbolPriority

Use symbolic when specifing priority of session scheduler jobs

JobPriorityRound

Priority rounding for session scheduler jobs

priorityMapping

Priority rounding for session scheduler jobs

maxInfoDirs

Maximum number of info directories

minMbdRefreshTime

The minimum period of a child MBD to serve queries in the MT way

enableStopAskingLicenses2LS

Stop asking license to LS not due to lack license

mbdQueryCPUs

MBD child query processes will only run on the following CPUs

defaultApp

The default application profile assigned to jobs

enableStream

Streaming of lsbatch data is enabled

streamFile

File to which lsbatch data is streamed

streamSize

File size in MB to which lsbatch data is streamed

syncUpHostStatusWithLIM

Sync up host status with master LIM is enabled

defaultSLA

EGO Enabled SLA scheduling is enabled

slaTimer

EGO Enabled SLA scheduling timer period

mbdEgoTtl

EGO Enabled SLA scheduling time to live

mbdEgoConnTimeout

EGO Enabled SLA scheduling connection timeout

mbdEgoReadTimeout

EGO Enabled SLA scheduling read timeout

mbdUseEgoMXJ

EGO Enabled SLA scheduling use MXJ flag

mbdEgoReclaimByQueue

EGO Enabled SLA scheduling reclaim by queue

defaultSLAvelocity

EGO Enabled SLA scheduling default velocity

exitRateTypes

Type of host exit rate exception handling types: EXIT_RATE_TYPE

globalJobExitRate

Type of host exit rate exception handling types: GLOBAL_EXIT_RATE

enableJobExitRatePerSlot

Type of host exit rate exception handling types ENABLE_EXIT_RATE_PER_SLOT

enableMetric

Performance metrics monitor is enabled flag

schMetricsSample

Performance metrics monitor sample period flag

maxApsValue

used to bound: (1) factors, (2) weights, and (3) APS values

newjobRefresh

Child mbatchd gets updated information about new jobs from the parent mbatchd

preemptJobType

Job type to preempt, PREEMPT_JOBTYPE_BACKFILL, PREEMPT_JOBTYPE_EXCLUSIVE

defaultJgrp

The default job group assigned to jobs

jobRunlimitRatio

Max ratio between run limit and runtime estimation

jobIncludePostproc

Enable the post-execution processing of the job to be included as part of the job flag

jobPostprocTimeout

Timeout of post-execution processing

sschedUpdateSummaryInterval

The interval, in seconds, for updating the session scheduler status summary

sschedUpdateSummaryByTask

The number of completed tasks for updating the session scheduler status summary

sschedRequeueLimit

The maximum number of times a task can be requeued via requeue exit values

sschedRetryLimit

The maximum number of times a task can be retried after a dispatch error

sschedMaxTasks

The maximum number of tasks that can be submitted in one session

sschedMaxRuntime

The maximum run time of a single task

sschedAcctDir

The output directory for task accounting files

jgrpAutoDel

If TRUE enable the job group automatic deletion functionality (default is FALSE).

maxJobPreempt

Maximum number of job preempted times.

maxJobRequeue

Maximum number of job re-queue times.

noPreemptRunTimePercent

No preempt run time percent.

maxStreamFileNum

Maximum number of backup stream.utc files.

privilegedUserForceBkill

If enforced only admin can use the bkill -r option.

intersectCandidateHosts

Jobs run on only on hosts belonging to the intersection of the queue the job was submitted to, advance reservation hosts, and any hosts specified by bsub -m at the time of submission.

enforceOneUGLimit

Enforces the limitations of a single specified user group.

logRuntimeESTExceeded

Logging of runtime estimation events.

computeUnitTypes

Compute unit types.

fairAdjustFactor

Fairshare adjustment weighting factor.

noPreemptFinishTimePercent

No preempt finish time percent.

slotReserveQueueLimit

The reservation request being within JL/U.

maxJobPercentagePerSession

Job accept limit percentage.

useSuspSlots

The low priority job will use the slots freed by preempted jobs.

RETURN VALUES

pointer:parameterInfo

The function was a success, returns a pointer to a parameterInfo structure.

char:NULL

Function failed.

ERRORS

If the function fails, lsberrno is set to indicate the error.

SEE ALSO

Related APIs

none

Equivalent line command

none

Files

$LSB_CONFDIR/cluster_name/lsb.params


Platform Computing Inc.
www.platform.com
Knowledge Center         Contents    Previous  Next