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 static  long    fract[3] = {
  80         800,                    /* (4.0/5.0) 5 second average */
  81         966,                    /* (29.0/30.0) 30 second average */
  82         983,                    /* (59.0/60.) 1 minute average */
  83 };
  84
  85 void
  86 compute_mach_factor(void)
  87 {
  88         register processor_set_t        pset;
  89         register processor_t            processor;
  90         register int                            ncpus;
  91         register int                            nthreads;
  92         register long                           factor_now = 0L;
  93         register long                           average_now = 0L;
  94         register long                           load_now = 0L;
  95
  96         pset = &default_pset;
  97         simple_lock(&pset->processors_lock);
  98         if ((ncpus = pset->processor_count) > 0) {
  99                 /*
 100                  *      Count number of threads.
 101                  */
 102                 nthreads = pset->runq.count;
 103                 processor = (processor_t)queue_first(&pset->processors);
 104                 while (!queue_end(&pset->processors, (queue_entry_t)processor)) {
 105                         nthreads += processor->runq.count;
 106
 107                         processor = (processor_t)queue_next(&processor->processors);
 108                 }
 109
 110                 /*
 111                  * account for threads on cpus.
 112                  */
 113                 nthreads += ncpus - pset->idle_count;
 114
 115                 /*
 116                  *      The current thread (running this calculation)
 117                  *      doesn't count; it's always in the default pset.
 118                  */
 119                 if (pset == &default_pset)
 120                         nthreads -= 1;
 121
 122                 if (nthreads >= ncpus)
 123                         factor_now = (ncpus * LOAD_SCALE) / (nthreads + 1);
 124                 else
 125                         factor_now = (ncpus - nthreads) * LOAD_SCALE;
 126
 127                 if (nthreads > ncpus)
 128                         load_now = (nthreads << SCHED_SHIFT) / ncpus;
 129                 else
 130                         load_now = 0;
 131
 132                 /*
 133                  *      Load average and mach factor calculations for
 134                  *      those that ask about these things.
 135                  */
 136
 137                 average_now = (nthreads * LOAD_SCALE) / ncpus;
 138
 139                 pset->mach_factor =     ((pset->mach_factor << 2) + factor_now) / 5;
 140                 pset->load_average = ((pset->load_average << 2) + average_now) / 5;
 141
 142                 /*
 143                  *      sched_load is the only thing used by scheduler.
 144                  */
 145                 pset->sched_load = (pset->sched_load + load_now) >> 1;
 146         }
 147         else {
 148                 pset->mach_factor = pset->load_average = 0;
 149                 pset->sched_load = 0;
 150         }
 151
 152         simple_unlock(&pset->processors_lock);
 153
 154         /*
 155          *      And some ugly stuff to keep w happy.
 156          */
 157         {
 158                 register int i;
 159
 160                 for (i = 0; i < 3; i++) {
 161                         mach_factor[i] = ((mach_factor[i] * fract[i]) +
 162                                                 (factor_now * (LOAD_SCALE - fract[i]))) / LOAD_SCALE;
 163
 164                         avenrun[i] = ((avenrun[i] * fract[i]) +
 165                                                 (average_now * (LOAD_SCALE - fract[i]))) / LOAD_SCALE;
 166                 }
 167         }
 168 }