osfmk/kern/mach_factor.c

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22 /*
  23  * @OSF_COPYRIGHT@
  24  */
  25 /*
  26  * Mach Operating System
  27  * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
  28  * All Rights Reserved.
  29  *
  30  * Permission to use, copy, modify and distribute this software and its
  31  * documentation is hereby granted, provided that both the copyright
  32  * notice and this permission notice appear in all copies of the
  33  * software, derivative works or modified versions, and any portions
  34  * thereof, and that both notices appear in supporting documentation.
  35  *
  36  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  37  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  38  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  39  *
  40  * Carnegie Mellon requests users of this software to return to
  41  *
  42  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  43  *  School of Computer Science
  44  *  Carnegie Mellon University
  45  *  Pittsburgh PA 15213-3890
  46  *
  47  * any improvements or extensions that they make and grant Carnegie Mellon
  48  * the rights to redistribute these changes.
  49  */
  50 /*
  51  */
  52 /*
  53  *      File:   kern/mach_factor.c
  54  *      Author: Avadis Tevanian, Jr.
  55  *      Date:   1986
  56  *
  57  *      Compute the Mach Factor.
  58  */
  59
  60 #include <cpus.h>
  61
  62 #include <mach/machine.h>
  63 #include <mach/processor_info.h>
  64 #include <kern/sched.h>
  65 #include <kern/assert.h>
  66 #include <kern/processor.h>
  67 #include <kern/thread.h>
  68 #if     MACH_KERNEL
  69 #include <mach/kern_return.h>
  70 #include <mach/port.h>
  71 #endif  /* MACH_KERNEL */
  72
  73 integer_t       avenrun[3] = {0, 0, 0};
  74 integer_t       mach_factor[3] = {0, 0, 0};
  75
  76 /*
  77  * Values are scaled by LOAD_SCALE, defined in processor_info.h
  78  */
  79 #define base(n)         ((n) << SCHED_TICK_SHIFT)
  80 #define frac(n)         (((base(n) - 1) * LOAD_SCALE) / base(n))
  81
  82 static  long    fract[3] = {
  83         frac(5),                /* 5 second average */
  84         frac(30),               /* 30 second average */
  85         frac(60),               /* 1 minute average */
  86 };
  87 #undef base
  88 #undef frac
  89
  90 void
  91 compute_mach_factor(void)
  92 {
  93         register processor_set_t        pset;
  94         register processor_t            processor;
  95         register int                            ncpus;
  96         register int                            nthreads;
  97         register long                           factor_now = 0L;
  98         register long                           average_now = 0L;
  99         register long                           load_now = 0L;
 100
 101         pset = &default_pset;
 102         simple_lock(&pset->processors_lock);
 103         if ((ncpus = pset->processor_count) > 0) {
 104                 /*
 105                  *      Count number of threads.
 106                  */
 107                 nthreads = pset->runq.count;
 108                 processor = (processor_t)queue_first(&pset->processors);
 109                 while (!queue_end(&pset->processors, (queue_entry_t)processor)) {
 110                         nthreads += processor->runq.count;
 111
 112                         processor = (processor_t)queue_next(&processor->processors);
 113                 }
 114
 115                 /*
 116                  * account for threads on cpus.
 117                  */
 118                 nthreads += ncpus - pset->idle_count;
 119
 120                 /*
 121                  *      The current thread (running this calculation)
 122                  *      doesn't count; it's always in the default pset.
 123                  */
 124                 if (pset == &default_pset)
 125                         nthreads -= 1;
 126
 127                 if (nthreads >= ncpus)
 128                         factor_now = (ncpus * LOAD_SCALE) / (nthreads + 1);
 129                 else
 130                         factor_now = (ncpus - nthreads) * LOAD_SCALE;
 131
 132                 if (nthreads > ncpus)
 133                         load_now = (nthreads << SCHED_SHIFT) / ncpus;
 134                 else
 135                         load_now = 0;
 136
 137                 /*
 138                  *      Load average and mach factor calculations for
 139                  *      those that ask about these things.
 140                  */
 141
 142                 average_now = (nthreads * LOAD_SCALE) / ncpus;
 143
 144                 pset->mach_factor =     ((pset->mach_factor << 2) + factor_now) / 5;
 145                 pset->load_average = ((pset->load_average << 2) + average_now) / 5;
 146
 147                 /*
 148                  *      sched_load is the only thing used by scheduler.
 149                  */
 150                 pset->sched_load = (pset->sched_load + load_now) >> 1;
 151         }
 152         else {
 153                 pset->mach_factor = pset->load_average = 0;
 154                 pset->sched_load = 0;
 155         }
 156
 157         simple_unlock(&pset->processors_lock);
 158
 159         /*
 160          *      And some ugly stuff to keep w happy.
 161          */
 162         {
 163                 register int i;
 164
 165                 for (i = 0; i < 3; i++) {
 166                         mach_factor[i] = ((mach_factor[i] * fract[i]) +
 167                                                 (factor_now * (LOAD_SCALE - fract[i]))) / LOAD_SCALE;
 168
 169                         avenrun[i] = ((avenrun[i] * fract[i]) +
 170                                                 (average_now * (LOAD_SCALE - fract[i]))) / LOAD_SCALE;
 171                 }
 172         }
 173 }