FreeBSD/Linux Kernel Cross Reference
sys/kern/mach_factor.c

     /* 
      * Mach Operating System
      * Copyright (c) 1993-1987 Carnegie Mellon University
      * All Rights Reserved.
      * 
      * Permission to use, copy, modify and distribute this software and its
      * documentation is hereby granted, provided that both the copyright
      * notice and this permission notice appear in all copies of the
      * software, derivative works or modified versions, and any portions
     * thereof, and that both notices appear in supporting documentation.
     * 
     * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
     * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
     * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
     * 
     * Carnegie Mellon requests users of this software to return to
     * 
     *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
     *  School of Computer Science
     *  Carnegie Mellon University
     *  Pittsburgh PA 15213-3890
     * 
     * any improvements or extensions that they make and grant Carnegie Mellon
     * the rights to redistribute these changes.
     */
    /*
     * HISTORY
     * $Log:        mach_factor.c,v $
     * Revision 2.8  93/11/17  17:14:40  dbg
     *      New run queue structures.
     *      [93/04/09            dbg]
     * 
     *      Added ANSI prototypes.  Corrected calculation since
     *      compute_mach_factor is now called by a timeout routine, not a
     *      thread.
     * 
     * Revision 2.7  92/08/03  17:38:15  jfriedl
     *      removed silly prototypes
     *      [92/08/02            jfriedl]
     * 
     * Revision 2.6  92/05/21  17:14:39  jfriedl
     *      Added void to to compute_mach_factor().
     *      [92/05/16            jfriedl]
     * 
     * Revision 2.5  91/05/14  16:44:18  mrt
     *      Correcting copyright
     * 
     * Revision 2.4  91/02/05  17:27:51  mrt
     *      Changed to new Mach copyright
     *      [91/02/01  16:14:56  mrt]
     * 
     * Revision 2.3  90/06/02  14:55:09  rpd
     *      Removed host_load; host_info/HOST_LOAD_INFO supercedes it.
     *      [90/06/02            rpd]
     * 
     *      Updated to new processor set and scheduling technology.
     *      [90/03/26  22:11:20  rpd]
     * 
     * Revision 2.2  90/03/14  21:10:38  rwd
     *      Added host_load call to get avenrun.
     *      [90/01/28            rwd]
     * 
     * Revision 2.1  89/08/03  15:46:37  rwd
     * Created.
     * 
     * 20-Oct-88  David Golub (dbg) at Carnegie-Mellon University
     *      Fixed for MACH_KERNEL.
     *
     * 25-Mar-88  David Black (dlb) at Carnegie-Mellon University
     *      Added sched_load calculation.
     *
     *  4-Dec-87  David Black (dlb) at Carnegie-Mellon University
     *      Fix calculation to correctly account for threads that are
     *      actually on cpus.  This used to work by accident because if a
     *      processor is not idle, its idle thread was on the local runq;
     *      this is no longer the case.
     *
     * 18-Nov-87  Avadis Tevanian (avie) at Carnegie-Mellon University
     *      Removed conditionals, compute every second.
     *
     */
    /*
     *      File:   kern/mach_factor.c
     *      Author: Avadis Tevanian, Jr.
     *      Date:   1986
     *
     *      Compute the Mach Factor.
     */
    
    #include <cpus.h>
    
    #include <mach/machine.h>
    #include <kern/processor.h>
    #include <mach/processor_info.h>
    #include <kern/run_queues.h>
    
    /*
     *      Set this TRUE if compute_mach_factor() is run from a thread.
     *      Set this FALSE if it is called from a timeout.
    */
   
   #define COMPUTE_MACH_FACTOR_IN_THREAD   0       /* called from timeout */
   
   /*
    *      5 second, 30 second, and 1 minute averages:
    */
   long    avenrun[3]     = {0, 0, 0};     /* number of runnable threads */
   long    mach_factor[3] = {0, 0, 0};     /* mach factor */
   
   /*
    * Values are scaled by LOAD_SCALE, defined in processor_info.h
    */
   static  long    fract[3] = {
           800,                    /* (4.0/5.0) 5 second average */
           966,                    /* (29.0/30.0) 30 second average */
           983,                    /* (59.0/60.) 1 minute average */
   };
   
   void compute_mach_factor(void)
   {
           register processor_set_t pset;
           register int            ncpus;
           register int            nthreads;
           register long           factor_now;
           register long           average_now;
           register long           load_now;
   
           simple_lock(&all_psets_lock);
           queue_iterate(&all_psets, pset, processor_set_t, all_psets) {
   
               /*
                *  If no processors, this pset is in suspended animation.
                *  No load calculations are performed.
                */
               pset_lock(pset);
               if ((ncpus = pset->processor_count) > 0) {
   
                   /*
                    *      Count number of threads.
                    */
                   nthreads = pset->runq.count;
   #if     MACH_IO_BINDING
                   {
                       register processor_t                processor;
                       queue_iterate(&pset->processors, processor, processor_t,
                                     processors)
                       {
                           nthreads += processor->runq.count;
                       }
                   }
   #endif
   
                   /*
                    * account for threads on cpus.
                    */
                   nthreads += ncpus - pset->idle_count; 
   
   #if     COMPUTE_MACH_FACTOR_IN_THREAD
                   /*
                    *      The current thread (running this calculation)
                    *      doesn't count; it's always in the default pset.
                    */
                   if (pset == &default_pset)
                      nthreads -= 1;
   #endif
   
                   if (nthreads > ncpus) {
                       factor_now = (ncpus * LOAD_SCALE) / (nthreads + 1);
                       load_now = (nthreads << SCHED_SHIFT) / ncpus;
                   }
                   else {
                       factor_now = (ncpus - nthreads) * LOAD_SCALE;
                       load_now = SCHED_SCALE;
                   }
   
                   /*
                    *      Load average and mach factor calculations for
                    *      those that ask about these things.
                    */
   
                   average_now = nthreads * LOAD_SCALE;
   
                   pset->mach_factor =
                           ((pset->mach_factor << 2) + factor_now)/5;
                   pset->load_average =
                           ((pset->load_average << 2) + average_now)/5;
   
                   /*
                    *      And some ugly stuff to keep w happy.
                    */
                   if (pset == &default_pset) {
                       register int i;
   
                       for (i = 0; i < 3; i++) {
                           mach_factor[i] = ( (mach_factor[i]*fract[i])
                                    + (factor_now*(LOAD_SCALE-fract[i])) )
                                   / LOAD_SCALE;
                           avenrun[i] = ( (avenrun[i]*fract[i])
                                    + (average_now*(LOAD_SCALE-fract[i])) )
                                   / LOAD_SCALE;
                       }
                   }
   
                   /*
                    *      sched_load is the only thing used by scheduler.
                    *      It is always at least 1 (i.e. SCHED_SCALE).
                    */
                   pset->sched_load = (pset->sched_load + load_now) >> 1;
               }
   
               pset_unlock(pset);
           }
   
           simple_unlock(&all_psets_lock);
   }

Cache object: 82c785c34997094daf487eb7fa6bae7e