    NAME
         sge_priority - Grid Engine job priorities

    DESCRIPTION
         Grid Engine provide means for controlling job  dispatch  and
         run-time  priorities.  The  dispatch  priority indicates the
         importance of pending jobs  compared  with  each  other  and
         determines the order in which Grid Engine dispatches jobs to
         queue instances. The run-time priority  determines  the  CPU
         allocation that the operating system assigns to jobs.

      JOBS DISPATCH PRIORITY
         A job's dispatch priority is affected by a  number  of  fac-
         tors:

         o  the identity of the submitting user

         o  the project under which the job is submitted (or alterna-
            tively, the default project of the submitting user)

         o  any resources requested by the job

         o  the job's submit time

         o  the job's initiation deadline time (if specified)

         o  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  pol-
         icy  setup,  which  is  split into three top-level contribu-
         tions.   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  calcu-
         late  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 * pprio +
                      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  is  adding  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 deter-
         mine 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 com-
         parison to other resources. This is expressed  by  the  for-
         mula:

            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  sup-
         posedly  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  weight-
         ing 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 ticket policy unites functional, override and share tree
         policies in the ticket value ("tckts"), as is 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.
         See  the  Grid  Engine Installation and Administration Guide
         for details.

      JOB RUN-TIME PRIORITY
         The run-time priority can be dynamically adjusted  in  order
         to  meet  the goals set with the ticket policy. Dynamic run-
         time priority adjustment can be turned  off  (default)  glo-
         bally  using  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)  Grid  Engine  Installation  and  Administration
         Guide

    COPYRIGHT
         See sge_intro(1) for a full statement of rights and  permis-
         sions.