sge_priority - Grid Engine job priorities


       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.

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

       o  the identity of the submitting user;

       o  the project under which the job is submitted (or alternatively, 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 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
          urg =  rrcontr + wtcontr + dlcontr
       consists of the resource requirement contribution (rrcontr), the
       waiting time contribution (wtcontr) and the deadline contribution

       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
          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,
           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.

       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.


       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.

SGE 8.1.3pre                      2007-01-05                   SGE_PRIORITY(5)

Man(1) output converted with man2html