/*
** COPYRIGHT (c) 1998 BY COMPAQ COMPUTER CORPORATION ALL RIGHTS RESERVED.
**
** THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED
** ONLY IN ACCORDANCE OF THE TERMS OF SUCH LICENSE AND WITH THE
** INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER
** COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
** OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY
** TRANSFERRED.
**
** THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE
** AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY COMPAQ COMPUTER
** CORPORATION.
**
** COMPAQ ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS
** SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY COMPAQ OR DIGITAL.
**
**=====================================================================
** WARNING - This example is provided for instructional and demo
** purposes only. The resulting program should not be
** run on systems which make use of soft-affinity
** features of OpenVMS, or while running applications
** which are tuned for precise processor configurations.
** We are continuing to explore enhancements such as this
** program which will be refined and integrated into
** future releases of OpenVMS.
**=====================================================================
**
** GCU$BALANCER.C - OpenVMS Galaxy CPU Load Balancer.
**
** This is an example of a privileged application which dynamically
** reassigns CPU resources among instances in an OpenVMS Galaxy. The
** program must be run on each participating instance. Each image
** will create, or map to, a small shared memory section and periodically
** post information regarding the depth of that instances' COM queues.
** Based upon running averages of this data, each instance will
** determine the most, and least busy instance. If these factors
** exist for a specified duration, the least busy instance having
** available secondary processors, will reassign one of its processors
** to the most busy instance, thereby effectively balancing processor
** usage across the OpenVMS Galaxy. The program provides command line
** arguments to allow tuning of the load balancing algorithm.
** The program is admittedly shy on error handling.
**
** This program uses the following OpenVMS Galaxy system services:
**
** SYS$CPU_TRANSITION - CPU reassignment
** SYS$CRMPSC_GDZRO_64 - Shared memory creation
** SYS$SET_SYSTEM_EVENT - OpenVMS Galaxy event notification
** SYS$*_GALAXY_LOCK_* - OpenVMS Galaxy locking
**
** Since OpenVMS Galaxy resources are always reassigned via a "push"
** model, where only the owner instance can release its resources,
** one copy of this process must run on each instance in the OpenVMS
** Galaxy.
**
** ENVIRONMENT: OpenVMS V7.2 Multiple-instance Galaxy.
**
** REQUIRED PRIVILEGES: CMKRNL required to count CPU queues
** SHMEM required to map shared memory
**
** BUILD/COPY INSTRUCTIONS:
**
** Compile and link the example program as described below, or copy the
** precompiled image found in SYS$EXAMPLES:GCU$BALANCER.EXE to
** SYS$COMMON:[SYSEXE]GCU$BALANCER.EXE
**
** If your OpenVMS Galaxy instances utilize individual system disks, you
** will need to do the above for each instance.
**
** If you change the example program, compile and link it as follows:
**
** $ CC GCU$BALANCER.C+SYS$LIBRARY:SYS$LIB_C/LIBRARY
** $ LINK/SYSEXE GCU$BALANCER
**
** STARTUP OPTIONS:
**
** You must establish a DCL command for this program. We have provided a
** sample command table file for this purpose. To install the new command,
** do the following:
**
** $ SET COMMAND/TABLE=SYS$LIBRARY:DCLTABLES -
** /OUT=SYS$COMMON:[SYSLIB]DCLTABLES GCU$BALANCER.CLD
**
** This command inserts the new command definition into DCLTABLES.EXE
** in your common system directory. The new command tables will take
** effect when the system is rebooted. If you would like to avoid a
** reboot, do the following:
**
** $ INSTALL REPLACE SYS$COMMON:[SYSLIB]DCLTABLES.EXE
**
** After this command, you will need to log out, then log back in to
** use the command from any active processes. Alternatively, if you
** would like to avoid logging out, do the following from each process
** you would like to run the balancer from:
**
** $ SET COMMAND GCU$BALANCER.CLD
**
** Once your command has been established, you may use the various
** command line parameters to control the balancer algorithm.
**
** $ CONFIGURE BALANCER{/STATISTICS} x y time
**
** Where: "x" is the number of load samples to take.
** "y" is the number of queued processes required to trigger
** resource reassignment.
** "time" is the delta time between load sampling.
**
** The /STATISTICS qualifier causes the program to display a
** continuous status line. This is useful for tuning the parameters.
** This output is not visible if the balancer is run detached, as is
** the case if it is invoked via the GCU. It is intended to be used
** only when the balancer is invoked directly from DCL in a DECterm
** window.
**
** For example: $ CONFIG BAL 3 1 00:00:05.00
**
** Starts the balancer which samples the system load every
** 5 seconds. After 3 samples, if the instance has one or
** more processes in the COM queue, a resource (CPU)
** reassignment will occur, giving this instance another CPU.
**
** GCU STARTUP:
**
** The GCU provides a menu item for launching SYS$SYSTEM:GCU$BALANCER.EXE
** and a dialog for altering the balancer algorithm. These features will
** only work if the balancer image is properly installed as described
** the the following paragraphs.
**
** To use the GCU-resident balancer startup option, you must:
**
** 1) Compile, link, or copy the balancer image as described previously.
** 2) Invoke the GCU via: $ CONFIGURE GALAXY You may need to set your
** DECwindows display to a suitably configured workstation or PC.
** 3) Select the "CPU Balancer" entry from the "Galaxy" menu.
** 4) Select appropriate values for your system. This may take some
** testing. By default, the values are set aggressively so that
** the balancer action can be readily observed. If your system is
** very heavily loaded, you will need to increase the values
** accordingly to avoid excessive resource reassignment. The GCU
** does not currently save these values, so you may want to write
** them down once you are satisfied.
** 5) Select the instance/s you wish to have participate, then select
** the "Start" function, then press OK. The GCU should launch the
** process GCU$BALANCER on all selected instances. You may want to
** verify these processes have been started.
**
** SHUTDOWN WARNING:
**
** In an OpenVMS Galaxy, no process may have shared memory mapped on an
** instance when it leaves the Galaxy, as during a shutdown. Because of
** this, SYS$MANAGER:SYSHUTDWN.COM must be modified to stop the process
** if the GCU$BALANCER program is run from a SYSTEM UIC. Processes in the
** SYSTEM UIC group are not terminated by SHUTDOWN.COM when shutting down
** or rebooting OpenVMS. If a process still has shared memory mapped when
** an instance leaves the Galaxy, the instance will crash with a
** GLXSHUTSHMEM bugcheck.
**
** To make this work, SYS$MANAGER:SYSHUTDWN.COM must stop the process as
** shown in the example below. Alternatively, the process can be run
** under a suitably privileged, non-SYSTEM UIC.
**
** SYSHUTDWN.COM EXAMPLE - Paste into SYS$MANAGER:SYSHUTDWN.COM
**
** $!
** $! If the GCU$BALANCER image is running, stop it to release shmem.
** $!
** $ procctx = f$context("process",ctx,"prcnam","GCU$BALANCER","eql")
** $ procid = f$pid(ctx)
** $ if procid .NES. "" then $ stop/id='procid'
**
** Note, you could also just do a "$ STOP GCU$BALANCER" statement.
**
** OUTPUTS:
**
** If the logical name GCU$BALANCER_VERIFY is defined, notify the
** SYSTEM account when CPUs are reassigned. If the /STATISTICS
** qualifier is specified, a status line is continually displayed,
** but only when run directly from the command line.
**
** REVISION HISTORY:
**
** 02-Dec-1998 Greatly improved instructions.
** 03-Nov-1998 Improved instructions.
** 24-Sep-1998 Initial code example and integration with GCU.
*/
#include <BRKDEF>
#include <BUILTINS>
#include <CSTDEF>
#include <DESCRIP>
#include <GLOCKDEF>
#include <INTS>
#include <PDSCDEF>
#include <PSLDEF>
#include <SECDEF>
#include <SSDEF>
#include <STARLET>
#include <STDIO>
#include <STDLIB>
#include <STRING>
#include <SYIDEF>
#include <SYSEVTDEF>
#include <VADEF>
#include <VMS_MACROS>
#include <CPUDEF>
#include <IOSBDEF.H>
#include <EFNDEF.H>
/* For CLI */
#include <cli$routines.h>
#include <chfdef.h>
#include <climsgdef.h>
#define HEARTBEAT_RESTART 0 /* Flags for synchronization */
#define HEARTBEAT_ALIVE 1
#define HEARTBEAT_TRANSPLANT 2
#define GLOCK_TIMEOUT 100000 /* Sanity check, max time holding gLock */
#define _failed(x) (!((x) & 1))
$DESCRIPTOR(system_dsc, "SYSTEM"); /* Brkthru account name */
$DESCRIPTOR(gblsec_dsc, "GCU$BALANCER"); /* Global section name */
struct SYI_ITEM_LIST { /* $GETSYI item list format */
short buflen,item;
void *buffer,*length;
};
/* System information and an item list to use with $GETSYI */
static unsigned long total_cpus;
static uint64 partition_id;
static long max_instances = 32;
iosb g_iosb;
struct SYI_ITEM_LIST syi_itemlist[3] = {
{sizeof (long), SYI$_ACTIVECPU_CNT,&total_cpus, 0},
{sizeof (long), SYI$_PARTITION_ID, &partition_id,0},
{0,0,0,0}};
extern uint32 *SCH$AQ_COMH; /* Scheduler COM queue address */
unsigned long PAGESIZE; /* Alpha page size */
uint64 glock_table_handle; /* Galaxy lock table handle */
/*
** Shared Memory layout (64-bit words):
** ====================================
** 0 to n-1: Busy count, where 100 = 1 process in a CPU queue
** n to 2n-1: Heartbeat (status) for each instance
** 2n to 3n-1: Current CPU count on each instance
** 3n to 4n-1: Galaxy lock handles for modifying heartbeats
**
** where n = max_instances * sizeof(long).
**
** We assume the entire table (easily) fits in two Alpha pages.
*/
/* Shared memory pointers must be declared volatile */
volatile uint64 gs_va = 0; /* Shmem section address */
volatile uint64 gs_length = 0; /* Shmem section length */
volatile uint64 *gLocks; /* Pointers to gLock handles */
volatile uint64 *busycnt,*heartbeat,*cpucount;
/************************************************************************/
/* FUNCTION init_lock_tables - Map to the Galaxy locking table and */
/* create locks if needed. Place the lock handles in a shared memory */
/* region, so all processes can access the locks. */
/* */
/* ENVIRONMENT: Requires SHMEM and CMKRNL to create tables. */
/* INPUTS: None. */
/* OUTPUTS: Any errors from lock table creation. */
/************************************************************************/
int init_lock_tables (void)
{
int status,i;
unsigned long sanity;
uint64 handle;
unsigned int min_size, max_size;
/* Lock table names are 15-byte padded values, unique across a Galaxy. */
char table_name[] = "GCU_BAL_GLOCK ";
/* Lock names are 15-byte padded values, but need not be unique. */
char lock_name[] = "GCU_BAL_LOCK ";
/* Get the size of a Galaxy lock */
status = sys$get_galaxy_lock_size(&min_size,&max_size);
if (_failed(status)) return (status);
/*
** Create or map to a process space Galaxy lock table. We assume
** one page is enough to hold the locks. This will work for up
** to 128 instances.
*/
status = sys$create_galaxy_lock_table(table_name,PSL$C_USER,
PAGESIZE,GLCKTBL$C_PROCESS,0,min_size,&glock_table_handle);
if (_failed(status)) return (status);
/*
** Success case 1: SS$_CREATED
** We created the table, so populate it with locks and
** write the handles to shared memory so the other partitions
** can access them. Only one instance can receive SS$_CREATED
** for a given lock table; all other mappers will get SS$_NORMAL.
*/
if (status == SS$_CREATED)
{
printf ("%%GCU$BALANCER-I-CRELOCK, Creating G-locks\n");
for (i=0; i<max_instances; i++)
{
status = sys$create_galaxy_lock(glock_table_handle,lock_name,
min_size,0,0,0,&handle);
gLocks[i] = handle;
if (_failed(status)) return (status);
}
}
else
{
/*
** Success case 2: SS$_NORMAL
** We mapped the table, but did not create it. Spin until
** the creator fills the lock handles. NOTE: If the creator
** fails in the loop above and does not finish creating the
** locks, then we will be stuck waiting forever - so we
** use a sanity check here. Process space lock tables and
** memory regions are automatically deleted when all
** processes mapping them are deleted, so the worst case
** is this:
**
** - Process 1 starts, creates gLock table
** - Processes 2-n start and are waiting on gLock creation
** - Process 1 dies before completing gLock creation
** - Processes 2-n time out and exit; the half-initialized
** section and lock tables are deleted by VMS.
** - The user (or script) receives SS$_TIMEOUT and can
** now restart all processes with a "clean slate".
*/
sanity = 0;
printf ("%%GCU$BALANCER-I-WAITLOCK, Waiting for G-lock creation...\n");
while (gLocks[max_instances-1] == 0)
{
if (sanity++ > 1000000) return (SS$_TIMEOUT);
}
}
return (SS$_NORMAL);
}
/************************************************************************/
/* FUNCTION update_cpucount - Update the number of CPUs in this instance*/
/* */
/* ENVIRONMENT: Called directly or via a system event AST. */
/* INPUTS: None. */
/* OUTPUTS: Updates this instance's CPU count in shared memory. */
/************************************************************************/
void update_cpucount(int unused)
{
sys$getsyiw(EFN$C_ENF,0,0,&syi_itemlist,&g_iosb,0,0);
cpucount[partition_id] = total_cpus;
}
/************************************************************************/
/* FUNCTION cpu_q - Count the number of processes in CPU COM queues */
/* */
/* ENVIRONMENT: OpenVMS Kernel Mode. */
/* INPUTS: None. */
/* OUTPUTS: Returns the number of processes on the COM queues. */
/************************************************************************/
long cpu_q(void)
{
uint32 *head, *tmp;
long procs = 0;
int p;
head = SCH$AQ_COMH; /* Head of 1st COM queue */
sys_lock(SCHED,1,0); /* Obtain SCHED spinlock */
for (p=64; p>0; p--) /* Queues to scan (32 COM + 32 COMO) */
{
tmp = (uint32 *) *head; /* Look at first flink */
while (tmp != head) /* Compare vs. head of queue */
{
procs++; /* Different, count a job waiting */
tmp = (uint32 *) *tmp; /* Go to next queue entry */
}
head = head + 2; /* Go to next queue (increment by 2*32) */
} /* And scan it (loop to "for p...") */
sys_unlock(SCHED,0,0); /* Release SCHED spinlock */
return procs;
}
/************************************************************************/
/* FUNCTION lockdown - Lock the cpu_q routine into the working set */
/* so that it can't pagefault while at elevated IPL */
/* */
/* ENVIRONMENT: Requires CMKRNL privilege. */
/* INPUTS: None. */
/* OUTPUTS: None. */
/************************************************************************/
void lockdown(void)
{
struct pdscdef *proc_desc = (void *)cpu_q;
unsigned long sub_addr[2], locked_head[2], locked_code[2];
unsigned long status;
sub_addr[0] = (unsigned long) cpu_q;
sub_addr[1] = sub_addr[0] + PAGESIZE;
if (__PAL_PROBER((void *)sub_addr[0],sizeof(int),PSL$C_USER) != 0)
sub_addr[1] = sub_addr[0];
status = sys$lkwset(sub_addr,locked_head,PSL$C_USER);
if (_failed(status)) exit(status);
sub_addr[0] = proc_desc->pdsc$q_entry[0];
sub_addr[1] = sub_addr[0] + PAGESIZE;
if (__PAL_PROBER((void *)sub_addr[0],sizeof(int),PSL$C_USER) != 0)
sub_addr[1] = sub_addr[0];
status = sys$lkwset(sub_addr,locked_code,PSL$C_USER);
if (_failed(status)) exit(status);
}
/************************************************************************/
/* FUNCTION reassign_a_cpu - Reassign a single CPU to another instance. */
/* */
/* ENVIRONMENT: Requires CMKRNL privilege. */
/* INPUTS: most_busy_id: partition ID of destination. */
/* OUTPUTS: None. */
/* */
/* Donate one CPU at a time - then wait for the remote instance to */
/* reset its heartbeat and recalculate its load. */
/************************************************************************/
void reassign_a_cpu(int most_busy_id)
{
int status,i;
static char op_msg[255];
static char iname_msg[1];
$DESCRIPTOR(op_dsc,op_msg);
$DESCRIPTOR(iname_dsc,"");
iname_dsc.dsc$w_length = 0;
/* Update CPU info */
status = sys$getsyiw(EFN$C_ENF,0,0,&syi_itemlist,&g_iosb,0,0);
if (_failed(status)) exit(status);
/* Don't attempt reassignment if we are down to one CPU */
if (total_cpus > 1)
{
status = sys$acquire_galaxy_lock(gLocks[most_busy_id],GLOCK_TIMEOUT,0);
if (_failed(status)) exit(status);
heartbeat[most_busy_id] = HEARTBEAT_TRANSPLANT;
status = sys$release_galaxy_lock(gLocks[most_busy_id]);
if (_failed(status)) exit(status);
status = sys$cpu_transitionw(CST$K_CPU_MIGRATE,CST$K_ANY_CPU,0,
most_busy_id,0,0,0,0,0,0);
if (status & 1)
{
if (getenv ("GCU$BALANCER_VERIFY"))
{
sprintf(op_msg,
"\n\n*****GCU$BALANCER: Reassigned a CPU to instance %li\n",
most_busy_id);
op_dsc.dsc$w_length = strlen(op_msg);
sys$brkthru(0,&op_dsc,&system_dsc,BRK$C_USERNAME,0,0,0,0,0,0,0);
}
update_cpucount(0); /* Update the CPU count after donating one */
}
}
}
/************************************************************************/
/* IMAGE ENTRY - MAIN */
/* */
/* ENVIRONMENT: OpenVMS Galaxy */
/* INPUTS: None. */
/* OUTPUTS: None. */
/************************************************************************/
int main(int argc, char **argv)
{
int show_stats = 0;
long busy,most_busy,nprocs;
int64 delta;
unsigned long status,i,j,k,system_cpus,instances;
unsigned long arglst = 0;
uint64 version_id[2] = {0,1};
uint64 region_id = VA$C_P0;
uint64 most_busy_id,cpu_hndl = 0;
/* Static descriptors for storing parameters. Must match CLD defs */
$DESCRIPTOR(p1_desc,"P1");
$DESCRIPTOR(p2_desc,"P2");
$DESCRIPTOR(p3_desc,"P3");
$DESCRIPTOR(p4_desc,"P4");
$DESCRIPTOR(stat_desc,"STATISTICS");
/* Dynamic descriptors for retrieving parameter values */
struct dsc$descriptor_d samp_desc = {0,DSC$K_DTYPE_T,DSC$K_CLASS_D,0};
struct dsc$descriptor_d proc_desc = {0,DSC$K_DTYPE_T,DSC$K_CLASS_D,0};
struct dsc$descriptor_d time_desc = {0,DSC$K_DTYPE_T,DSC$K_CLASS_D,0};
struct SYI_ITEM_LIST syi_pagesize_list[3] = {
{sizeof (long), SYI$_PAGE_SIZE ,&PAGESIZE ,0},
{sizeof (long), SYI$_GLX_MAX_MEMBERS,&max_instances,0},
{0,0,0,0}};
/*
** num_samples and time_desc determine how often the balancer should check
** to see if any other instance needs more CPUs. num_samples determines the
** number of samples used to calculate the running average, and sleep_dsc
** determines the amount of time between samples.
**
** For example, a sleep_dsc of 30 seconds and a num_samples of 20 means that
** a running average over the last 10 minutes (20 samples * 30 secs) is used
** to balance CPUs.
**
** load_tolerance is the minimum load difference which triggers a CPU
** migration. 100 is equal to 1 process in the computable CPU queue.
*/
int num_samples; /* Number of samples in running average */
int load_tolerance; /* Minimum load diff to trigger reassignment */
/* Parse the CLI */
/* CONFIGURE VERB */
status = CLI$PRESENT(&p1_desc); /* BALANCER */
if (status != CLI$_PRESENT) exit(status);
status = CLI$PRESENT(&p2_desc); /* SAMPLES */
if (status != CLI$_PRESENT) exit(status);
status = CLI$PRESENT(&p3_desc); /* PROCESSES */
if (status != CLI$_PRESENT) exit(status);
status = CLI$PRESENT(&p4_desc); /* TIME */
if (status != CLI$_PRESENT) exit(status);
status = CLI$GET_VALUE(&p2_desc,&samp_desc);
if (_failed(status)) exit(status);
status = CLI$GET_VALUE(&p3_desc,&proc_desc);
if (_failed(status)) exit(status);
status = CLI$GET_VALUE(&p4_desc,&time_desc);
if (_failed(status)) exit(status);
status = CLI$PRESENT(&stat_desc);
show_stats = (status == CLI$_PRESENT) ? 1 : 0;
num_samples = atoi(samp_desc.dsc$a_pointer);
if (num_samples <= 0) num_samples = 3;
load_tolerance = (100 * (atoi(proc_desc.dsc$a_pointer)));
if (load_tolerance <= 0) load_tolerance = 100;
if (show_stats)
printf("Args: Samples: %d, Processes: %d, Time: %s\n",
num_samples,load_tolerance/100,time_desc.dsc$a_pointer);
lockdown(); /* Lock down the cpu_q subroutine */
/* Get the page size and max members for this system */
status = sys$getsyiw(EFN$C_ENF,0,0,&syi_pagesize_list,&g_iosb,0,0);
if (_failed(status)) return (status);
if (max_instances == 0) max_instances = 1;
/* Get our partition ID and initial CPU info */
status = sys$getsyiw(EFN$C_ENF,0,0,&syi_itemlist,&g_iosb,0,0);
if (_failed(status)) return (status);
/* Map two pages of shared memory */
status = sys$crmpsc_gdzro_64(&gblsec_dsc,version_id,0,PAGESIZE+PAGESIZE,
®ion_id,0,PSL$C_USER,(SEC$M_EXPREG|SEC$M_SYSGBL|SEC$M_SHMGS),
&gs_va,&gs_length);
if (_failed(status)) exit(status);
/* Initialize the pointers into shared memory */
busycnt = (uint64 *) gs_va;
heartbeat = (uint64 *) gs_va + max_instances;
cpucount = (uint64 *) heartbeat + max_instances;
gLocks = (uint64 *) cpucount + max_instances;
cpucount[partition_id] = total_cpus;
/* Create or map the Galaxy lock table */
status = init_lock_tables();
if (_failed(status)) exit(status);
/* Initialize delta time for sleeping */
status = sys$bintim(&time_desc,&delta);
if (_failed(status)) exit(status);
/*
** Register for CPU migration events. Whenever a CPU is added to
** our active set, the routine "update_cpucount" will fire.
*/
status = sys$set_system_event(SYSEVT$C_ADD_ACTIVE_CPU,
update_cpucount,0,0,SYSEVT$M_REPEAT_NOTIFY,&cpu_hndl);
if (_failed(status)) exit(status);
/* Force everyone to resync before we do anything */
for (j=0; j<max_instances; j++)
{
status = sys$acquire_galaxy_lock(gLocks[j],GLOCK_TIMEOUT,0);
if (_failed(status)) exit(status);
heartbeat[j] = HEARTBEAT_RESTART;
status = sys$release_galaxy_lock (gLocks[j]);
if (_failed(status)) exit(status);
}
printf("%%GCU$BALANCER-S-INIT, CPU balancer initialized.\n\n");
/*** Main loop ***/
do
{
/* Calculate a running average and update it */
nprocs = sys$cmkrnl(cpu_q,&arglst) * 100;
/* Check out our state... */
switch (heartbeat[partition_id])
{
case HEARTBEAT_RESTART: /* Mark ourself for reinitializition. */
{
update_cpucount(0);
status = sys$acquire_galaxy_lock(gLocks[partition_id],GLOCK_TIMEOUT,0);
if (_failed(status)) exit(status);
heartbeat[partition_id] = HEARTBEAT_ALIVE;
status = sys$release_galaxy_lock(gLocks[partition_id]);
if (_failed(status)) exit(status);
break;
}
case HEARTBEAT_ALIVE: /* Update running average and continue. */
{
busy = (busycnt[partition_id]*(num_samples-1)+nprocs)/num_samples;
busycnt[partition_id] = busy;
break;
}
case HEARTBEAT_TRANSPLANT: /* Waiting for a new CPU to arrive. */
{
/*
** Someone just either reset us, or gave us a CPU and put a wait on
** further donations. Reassure the Galaxy that we're alive, and
** calculate a new busy count.
*/
busycnt[partition_id] = nprocs;
status = sys$acquire_galaxy_lock(gLocks[partition_id],GLOCK_TIMEOUT,0);
if (_failed(status)) exit(status);
heartbeat[partition_id] = HEARTBEAT_ALIVE;
status = sys$release_galaxy_lock(gLocks[partition_id]);
if (_failed(status)) exit(status);
break;
}
default: /* This should never happen. */
{
exit(0);
break;
}
}
/* Determine the most_busy instance. */
for (most_busy_id=most_busy=i=0; i<max_instances; i++)
{
if (busycnt[i] > most_busy)
{
most_busy_id = (uint64) i;
most_busy = busycnt[i];
}
}
if (show_stats)
printf("Current Load: %3Ld, Busiest Instance: %Ld, Queue Depth: %4d\r",
busycnt[partition_id],most_busy_id,(nprocs/100));
/* If someone needs a CPU and we have an extra, dontate it. */
if ((most_busy > busy + load_tolerance) &&
(cpucount[partition_id] > 1) &&
(heartbeat[most_busy_id] != HEARTBEAT_TRANSPLANT) &&
(most_busy_id != partition_id))
{
reassign_a_cpu(most_busy_id);
}
/* Hibernate for a while and do it all again. */
status = sys$schdwk(0,0,&delta,0);
if (_failed(status)) exit(status);
status = sys$hiber();
if (_failed(status)) exit(status);
} while (1);
return (1);
}
|
