bionic (5) sge_priority.5.gz

Provided by: gridengine-common_8.1.9+dfsg-7build1_all bug

NAME

       sge_priority - Grid Engine job priorities

DESCRIPTION

       Grid  Engine provides a means for controlling job dispatch and run-time priorities. The dispatch priority
       indicates the relative importance of pending jobs and determines the order in which Grid Engine initially
       considers  dispatching  jobs  to  queue  instances, if the relevant resources are available.  (The actual
       running order may be influenced may be influenced by other factors, such as reservations.)  The  run-time
       priority determines the CPU allocation that the operating system assigns to jobs.

   JOBS DISPATCH PRIORITY
       A  job's  dispatch priority (display in the "reduced" output format of qstat(1)), is affected by a number
       of factors:

       •  the identity of the submitting user;

       •  the project under which the job is submitted (or alternatively, the default project of the  submitting
          user);

       •  any resources requested by the job;

       •  the job's submit time;

       •  the job's initiation deadline time (if specified);

       •  the -p priority specified for the job (also known as the POSIX priority "pprio").

       The  effect of each of these is governed by the overall policy setup, which is split into three top-level
       contributions.  Each of  these  is  configured  through  the  sched_conf(5)  parameters  weight_priority,
       weight_ticket  and  weight_urgency.  These three parameters control to what degree POSIX priority, ticket
       policy,  and  urgency  policy  are  in  effect.  To  facilitate  interpretation,   the   raw   priorities
       ("tckts"/"urg"/"ppri")  are  normalized ("ntckts"/"nurg"/"npprior") before they are used to calculate job
       priorities ("prio").  Normalization maps each raw urgency/ticket/priority  value into a range  between  0
       and 1.

          npprior = normalized(ppri)
          nurg    = normalized(urg)
          ntckts  = normalized(tckts)

          prio    = weight_priority * npprio +
                    weight_urgency  * nurg +
                    weight_ticket   * ntckts

       The higher a job's priority value, the earlier it gets dispatched.

       The urgency policy defines an urgency value for each job. The urgency value
          urg =  rrcontr + wtcontr + dlcontr
       consists  of the resource requirement contribution (rrcontr), the waiting time contribution (wtcontr) and
       the deadline contribution (dlcontr).

       The resource requirement contribution adds up all resource requirements of a job into  a  single  numeric
       value.
          rrcontr = Sum over all(hrr)
       with  an  hrr  for each hard resource request.  Depending on the resource type, two different methods are
       used to determine the value to be used for  hrr  here.  For  numeric  type  resource  requests,  the  hrr
       represents  how  much  of a resource a job requests (on a per-slot basis for PE jobs) and how "important"
       this resource is considered in comparison to other resources. This is expressed by the formula:
          hrr = rurg * assumed_slot_allocation * request
       where the resource's urgency value (rurg)  is  as  specified  under  urgency  in  complex(5),  the  job's
       assumed_slot_allocation  represents  the number of slots supposedly assigned to the job, and the per-slot
       request is that which was specified using the -l qsub(1) option. For string-type requests the formula  is
       simply
          hrr = rurg
       and directly assigns the resource urgency value as specified under urgency in complex(5).

       The waiting time contribution represents a weighted waiting time of the jobs
          wtcontr = waiting_time * weight_waiting_time
       with the waiting time in seconds and the weight_waiting_time value as specified in sched_conf(5).

       The  deadline  contribution has an increasing effect as jobs approach their deadline initiation time (see
       the -dl option  in  qsub(1)).   It  is  defined  as  the  quotient  of  the  weight_deadline  value  from
       sched_conf(5) and the (steadily decreasing) free time in seconds until deadline initiation time
          dlcontr = weight_deadline / free_time
       or  is  set  to  0  for  non-deadline  jobs.  After the deadline passes, the value is static and equal to
       weight_deadline.  The qstat(1) -urg option displays urgency information for jobs.

       The ticket policy unites functional, override and share  tree  policies  in  the  ticket  value  (tckts),
       defined  as  the  sum  of the specific ticket values (ftckt/otckt/stckt) for each sub-policy (functional,
       override, share):
           tckts = ftckt + otckt + stckt

       The ticket policies provide a broad range  of  means  for  influencing  both  job  dispatch  and  runtime
       priorities  on  a  per  job,  per  user, per project, and per department basis.  The qstat(1) -ext option
       displays ticket information for jobs.

   JOB RUN-TIME PRIORITY
       The run-time priority can be dynamically adjusted in order to meet the goals set with the  ticket  policy
       when  execution hosts are over-subscribed. Dynamic run-time priority adjustment can be turned on globally
       using reprioritize in sge_conf(5) and reprioritize_interval in sched_conf(5).   If  no  dynamic  run-time
       priority adjustment is done at a host level, the priority specification in queue_conf(5) is in effect.

       Note that urgency and POSIX priorities do not affect runtime priority.

SEE ALSO

       sge_intro(1), complex(5), qstat(1), qsub(1), sched_conf(5), sge_conf(5)

       See sge_intro(1) for a full statement of rights and permissions.