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 uint32_t        avenrun[3] = {0, 0, 0};
  74 uint32_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 uint32_t         fract[3] = {
  83         frac(5),                /* 5 second average */
  84         frac(30),               /* 30 second average */
  85         frac(60),               /* 1 minute average */
  86 };
  87
  88 #undef base
  89 #undef frac
  90
  91 void
  92 compute_mach_factor(void)
  93 {
  94         register processor_set_t        pset = &default_pset;
  95         register int                            ncpus;
  96         register int                            nthreads, nshared;
  97         register uint32_t                       factor_now = 0;
  98         register uint32_t                       average_now = 0;
  99         register uint32_t                       load_now = 0;
 100
 101         if ((ncpus = pset->processor_count) > 0) {
 102                 /*
 103                  *      Retrieve thread counts.
 104                  */
 105                 nthreads = pset->run_count;
 106                 nshared = pset->share_count;
 107
 108                 /*
 109                  *      Don't include the current thread.
 110                  */
 111                 nthreads -= 1;
 112
 113                 /*
 114                  *      Load average and mach factor calculations for
 115                  *      those which ask about these things.
 116                  */
 117                 average_now = nthreads * LOAD_SCALE;
 118
 119                 if (nthreads > ncpus)
 120                         factor_now = (ncpus * LOAD_SCALE) / (nthreads + 1);
 121                 else
 122                         factor_now = (ncpus - nthreads) * LOAD_SCALE;
 123
 124                 pset->mach_factor =     ((pset->mach_factor << 2) + factor_now) / 5;
 125                 pset->load_average = ((pset->load_average << 2) + average_now) / 5;
 126
 127                 /*
 128                  *      Compute the load factor used by the timesharing
 129                  *      algorithm.
 130                  */
 131                 if (nshared > nthreads)
 132                         nshared = nthreads;
 133
 134                 if (nshared > ncpus)
 135                         load_now = (nshared << SCHED_SHIFT) / ncpus;
 136
 137                 pset->sched_load = (pset->sched_load + load_now) >> 1;
 138         }
 139         else {
 140                 pset->mach_factor = pset->load_average = 0;
 141                 pset->sched_load = 0;
 142         }
 143
 144         /*
 145          * Compute old-style Mach load averages.
 146          */
 147         {
 148                 register int            i;
 149
 150                 for (i = 0; i < 3; i++) {
 151                         mach_factor[i] = ((mach_factor[i] * fract[i]) +
 152                                                 (factor_now * (LOAD_SCALE - fract[i]))) / LOAD_SCALE;
 153
 154                         avenrun[i] = ((avenrun[i] * fract[i]) +
 155                                                 (average_now * (LOAD_SCALE - fract[i]))) / LOAD_SCALE;
 156                 }
 157         }
 158
 159         /*
 160          * Call out to BSD for averunnable.
 161          */
 162         {
 163 #define AVGTICK_PERIOD          (5 << SCHED_TICK_SHIFT)
 164                 static uint32_t         avgtick_count;
 165                 extern void                     compute_averunnable(
 166                                                                 int                             nrun);
 167
 168                 if (++avgtick_count == 1)
 169                         compute_averunnable(nthreads);
 170                 else
 171                 if (avgtick_count >= AVGTICK_PERIOD)
 172                         avgtick_count = 0;
 173         }
 174 }