windows-server-2003/base/cluster/service/mm/srgputl.c

#ifdef __TANDEM
#pragma columns 79
#pragma page "srgputl.c - T9050 - utility routines for Regroup Module"
#endif

/* @@@ START COPYRIGHT @@@
**  Tandem Confidential:  Need to Know only
**  Copyright (c) 1995, Tandem Computers Incorporated
**  Protected as an unpublished work.
**  All Rights Reserved.
**
**  The computer program listings, specifications, and documentation
**  herein are the property of Tandem Computers Incorporated and shall
**  not be reproduced, copied, disclosed, or used in whole or in part
**  for any reason without the prior express written permission of
**  Tandem Computers Incorporated.
**
** @@@ END COPYRIGHT @@@
**/

/*---------------------------------------------------------------------------
 * This file (srgputl.c) contains the cluster_t data type implementation
 * and the node pruning algorithm used by Regroup.
 *---------------------------------------------------------------------------*/

#ifdef __cplusplus
   extern "C" {
#endif /* __cplusplus */


#include <wrgp.h>

/************************************************************************
 * ClusterInit,
 * ClusterUnion,
 * ClusterIntersection,
 * ClusterDifference,
 * ClusterCompare,
 * ClusterSubsetOf,
 * ClusterComplement,
 * ClusterMember,
 * ClusterInsert,
 * ClusterDelete,
 * ClusterCopy,
 * ClusterSwap,
 * ClusterNumMembers
 * =================
 *
 * Description:
 *
 *    Functions that implement operations on the cluster_t type.
 *
 * Algorithm:
 *
 *    Operates on the byte array that is the cluster_t type.
 *
 ************************************************************************/
_priv _resident void
ClusterInit(cluster_t c)
{
   int i;

   for (i = 0; i < BYTES_IN_CLUSTER; i++)
      c[i] = 0;
}

_priv _resident void
ClusterUnion(cluster_t dst, cluster_t src1, cluster_t src2)
{
   int i;

   for (i = 0; i < BYTES_IN_CLUSTER; i++)
      dst[i] = src1[i] | src2[i];
}

_priv _resident void
ClusterIntersection(cluster_t dst, cluster_t src1, cluster_t src2)
{
   int i;
   for (i = 0; i < BYTES_IN_CLUSTER; i++)
      dst[i] = src1[i] & src2[i];
}

_priv _resident void
ClusterDifference(cluster_t dst, cluster_t src1, cluster_t src2)
{
   int i;
   for (i = 0; i < BYTES_IN_CLUSTER; i++)
      dst[i] = src1[i] & (~src2[i]);
}

_priv _resident int ClusterCompare(cluster_t c1, cluster_t c2)
{
   int identical, i;

   identical = 1;
   for (i = 0; i < BYTES_IN_CLUSTER; i++)
   {
      if (c1[i] != c2[i])
      {
         identical = 0;
         break;
      }
   }
   return(identical);
}

_priv _resident int ClusterSubsetOf(cluster_t big, cluster_t small)
/* Returns 1 if set small = set big or small is a subset of big. */
{
   int subset, i;

   subset = 1;
   for (i = 0; i < BYTES_IN_CLUSTER; i++)
   {
      if ( (big[i] != small[i]) && ((big[i] ^ small[i]) & small[i]) )
      {
         subset = 0;
         break;
      }
   }
   return(subset);
}

_priv _resident void ClusterComplement(cluster_t dst, cluster_t src)
{
   int i;
   for (i = 0; i < BYTES_IN_CLUSTER; i++)
      dst[i] = ~src[i];
}

_priv _resident int ClusterMember(cluster_t c, node_t i)
{
   return((BYTE(c,i) >> (BYTEL-1-BIT(i))) & 1);
}

_priv _resident void ClusterInsert(cluster_t c, node_t i)
{
   BYTE(c, i) |= (1 << (BYTEL-1-BIT(i)));
}

_priv _resident void ClusterDelete(cluster_t c, node_t i)
{
   BYTE(c, i) &= ~(1 << (BYTEL-1-BIT(i)));
}

_priv _resident void ClusterCopy(cluster_t dst, cluster_t src)
{
   int i;

   for (i = 0; i < BYTES_IN_CLUSTER; i++)
      dst[i] = src[i];
}

_priv _resident void ClusterSwap(cluster_t c1, cluster_t c2)
{
   int i;
   unsigned char temp;

   for (i = 0; i < BYTES_IN_CLUSTER; i++)
   {
      temp  = c1[i];
      c1[i] = c2[i];
      c2[i] = temp;
   }
}

_priv _resident int  ClusterNumMembers(cluster_t c)
/* Returns the number of nodes in the cluster. */
{
   int num_members = 0, i, j;

   for (i = 0; i < BYTES_IN_CLUSTER; i++)
   {
      if (c[i])
      {
         for (j = 0; j < BYTEL; j++)
            if (c[i] & (1 << j))
               num_members++;
      }
   }
   return(num_members);
}

/************************************************************************
 * ClusterEmpty
 * =================
 *
 * Description:
 *
 *    Checks that a cluster has no members
 *
 * Parameters:
 *
 *    cluster_t c
 *       cluster to be examined
 *
 * Returns:
 *
 *    0 - cluster contains at least one node
 *    1 - cluster is empty
 *
 * Comment:
 *
 *    The proper place for this function is in srgputl.c
 *
 ************************************************************************/
int ClusterEmpty(cluster_t c)
{
   int i;

   for (i = 0; i < BYTES_IN_CLUSTER; i++)
   {
      if (c[i])
      {
         return 0;
      }
   }
   return 1;
}


/************************************************************************
 * rgp_select_tiebreaker
 * =====================
 *
 * Description:
 *
 *    Simple algorithm to select the tie-breaker.
 *
 * Parameters:
 *
 *    cluster_t cluster -
 *       cluster from which a tie-breaker is to be selected
 *
 * Returns:
 *
 *    node_t - the node number of the selected tie-breaker
 *
 * Algorithm:
 *
 *    The tie-breaker is defined as the lowest numbered node in the
 *    cluster.
 *
 ************************************************************************/
_priv _resident node_t
rgp_select_tiebreaker(cluster_t cluster)
{
   node_t i;

   for (i = 0; (i < (node_t) rgp->num_nodes) && !ClusterMember(cluster, i); i++);

   /* If the cluster does not have any members, we have a problem! */
   if (i >= (node_t) rgp->num_nodes)
      RGP_ERROR(RGP_INTERNAL_ERROR);

   return(i);
}


/*---------------------------------------------------------------------------
 * Node pruning algorithm used by Regroup.
 *---------------------------------------------------------------------------
 */

/************************************************************************
 * group_exists
 * ============
 *
 * Description:
 *
 *    Check if a specific group already exists or is a subset of a
 *    group that already exists.
 *
 * Parameters:
 *
 *    cluster_t groups[] -
 *       array of groups to examine
 *
 *    int numgroups -
 *       number of groups discovered so far
 *
 *    cluster_t g -
 *       specific group to check
 *
 * Returns:
 *
 *    int - 1 if the specified group exists in the array; 0 therwise.
 *
 * Algorithm:
 *
 *    Goes through the array and calls ClusterSubsetOf to check if the
 *    specified group g is a subset of the the array element.
 *
 ************************************************************************/
#if !defined(NT)
_priv _resident static
int
#endif
group_exists(cluster_t groups[], int numgroups, cluster_t g)
{
   int exists, i;

   exists = 0;
   for (i = 0; i < numgroups; i++)
   {
      if (ClusterSubsetOf(groups[i],g))
      {
         exists = 1;
         break;
      }
   }
   return(exists);
}


/************************************************************************
 * prune
 * =====
 *
 * Description:
 *
 *    Algorithm to find all fully connected groups based on # of
 *    disconnects in the matrix.
 *
 * Parameters:
 *
 *    disconnect_array disconnects -
 *       input : array of disconnects
 *
 *    int D -
 *       input : size of disconnects array
 *
 *    cluster_t live_nodes -
 *       input : set of all live nodes
 *
 *    cluster_t groups[] -
 *       output: array of fully-connected groups
 *
 * Returns:
 *
 *    int - the number of groups made;  0 if no groups or other error
 *
 * Algorithm:
 *
 *    Start with one group that contains the set of live nodes.
 *    More groups will be generated as disconnects are examined.
 *
 *    Process each disconnect in the disconnects array by applying
 *    the disconnect to the current set of fully-connected groups.
 *
 *    The effect of a disconnect on a fully-conncted group depends on
 *    whether the end points of the disconnect are in the group or not.
 *
 *    If the group contains neither or only one of the endpoints of
 *    the disconnect, the disconnect has no effect on the group.
 *
 *    If both endpoints of the disconnect are in the group, then the
 *    group is split into two groups - the original group without
 *    endpoint 1 and the original group without endpoint 2.
 *    New groups so generated should be discarded if they already
 *    exist or are subsets of currently existing groups.
 *
 *    After every disconnect is processed, we end up with the final
 *    set of fully-connected groups.
 *
 ************************************************************************/
#if !defined(NT)
_priv _resident static
#endif
int
prune(
   disconnect_array   disconnects,
   int                D,
   cluster_t          live_nodes,
   cluster_t          groups[])
{
   int  numgroups = 1, i, j;

   ClusterCopy(groups[0], live_nodes);

   for (i = 0; i < D; i ++)
   {
      for (j = 0; j < numgroups; j++)
      {
         /* Split a group that has both ends of the disconnect. */
         if (ClusterMember(groups[j],disconnects[i][0]) &&
             ClusterMember(groups[j],disconnects[i][1]))
         {
            /* Correct current group in place.
             * Add new group at the end of the array.
             */
            numgroups++;
            ClusterCopy(groups[numgroups-1], groups[j]);
            ClusterDelete(groups[j], disconnects[i][0]);
            ClusterDelete(groups[numgroups-1], disconnects[i][1]);

            /* Check if the new groups already exist or are subgroups
             * of existing groups.
             */

            /* First, check the group added at the end of the array. */
            if (group_exists(groups, numgroups-1, groups[numgroups-1]))
               numgroups--;

            /* Next, check the modified group at j.
             * To simplify the checking, switch it with the last element
             * of the array. If the group already exists, it should be
             * removed. Since the group is now the last element of the
             * array, removal requires only decrementing the array count.
             */
            ClusterSwap(groups[j], groups[numgroups-1]);
            if (group_exists(groups, numgroups-1, groups[numgroups-1]))
               numgroups--;
            j--; /* The j-th entry has been switched with the last entry;
                    it has to be examined again */
         }
      }
   }

   return(numgroups);
}


/************************************************************************
 * select_group_with_designated_node
 * =================================
 *
 * Description:
 *
 *    Function to pick an arbitrary fully connected group that
 *    includes a specified node.
 *
 * Parameters:
 *
 *    connectivity_matrix_t c -
 *       input : cluster's connectivity info
 *
 *    node_t selected_node -
 *       input : just find a fully-connected group that includes this node
 *
 *    cluster_t *group -
 *       output: group that includes selected_node
 *
 * Returns:
 *
 *    int - returns 1 if the specified node is alive and 0 if it is not
 *
 * Algorithm:
 *
 *    Start with a group that includes just the selected node.
 *    Then, examine nodes starting with node 0 and go up till the
 *    largest node number. If a node is alive, include it in the group
 *    if and only if it is connected to all current members of the
 *    group.
 *
 *    When all nodes are examined, we get a fully-connected group that
 *    includes the selected node. This is only one of potentially many
 *    fully-connected groups and is not necessarily the largest
 *    solution.
 *
 *    This order of examining nodes gives higher priority to lower
 *    numbered nodes.
 *
 ************************************************************************/
#if !defined(NT)
_priv _resident static
#endif
int
select_group_with_designated_node(
   connectivity_matrix_t   c,
   node_t                  selected_node,
   cluster_t               *group)
{
   node_t i, j;

   if (!node_considered_alive(selected_node))
      return(0);
   else
   {
      ClusterInit(*group);
      ClusterInsert(*group, selected_node);
      for (i = 0; i < (node_t) rgp->num_nodes; i++)
      {
         if ((i != selected_node) &&
             node_considered_alive(i) &&
             connected(i, selected_node)
            )
         {
            /* Check if i is connected to all members of the group
             * built so far.
             */
            for (j = 0; j < i; j++)
            {
               if (ClusterMember(*group, j) && !connected(j, i))
                  break;
            }
            if (j == i)  /* i is connected to all current members*/
               ClusterInsert(*group, i);
         }
      }
      return(1);
   }
}


/************************************************************************
 * MatrixInit
 * ==========
 *
 * Description:
 *
 *    Initialize the matrix c to show 0 connectivity.
 *
 * Parameters:
 *
 *    connectivity_matrix_t c - matrix to be set to 0s.
 *
 * Returns:
 *
 *    void - no return value
 *
 * Algorithm:
 *
 *    Calls ClusterInit to initialize the clusters in the matrix.
 *
 ************************************************************************/
_priv _resident void
MatrixInit(connectivity_matrix_t c)
{
   int i;

   for (i = 0; i < (node_t) rgp->num_nodes; i++)
   {
      ClusterInit(c[i]);
   }
}


/************************************************************************
 * MatrixSet
 * =========
 *
 * Description:
 *
 *    Set matrix[row,column] to 1.
 *
 * Parameters:
 *
 *    connectivity_matrix_t c - matrix to be modified
 *
 *    int row - row number
 *
 *    int column - column number
 *
 * Returns:
 *
 *    void - no return value
 *
 * Algorithm:
 *
 *    Calls ClusterInsert to set the appropriate bit (column) in the
 *    appropriate cluster (row) in the matrix.
 *
 ************************************************************************/
_priv _resident void
MatrixSet(connectivity_matrix_t c, int row, int column)
{
   ClusterInsert(c[row], (node_t) column);
}


/************************************************************************
 * MatrixOr
 * ========
 *
 * Description:
 *
 *    matrix t := t OR s
 *
 * Parameters:
 *
 *    connectivity_matrix_t  t - target matrix
 *
 *    connectivity_matrix_t  s - source matrix to be ORed into target
 *
 * Returns:
 *
 *    void - no return value
 *
 * Algorithm:
 *
 *    Calls ClusterUnion to OR the appropriate clusters (rows) in the
 *    matrices.
 *
 ************************************************************************/
_priv _resident void
MatrixOr(connectivity_matrix_t t, connectivity_matrix_t s)
{
   int i;

   for (i = 0; i < (node_t) rgp->num_nodes; i++)
      ClusterUnion(t[i], s[i], t[i]);
}


/************************************************************************
 * connectivity_complete
 * =====================
 *
 * Description:
 *
 *    Boolean function that checks if a given connectivity matrix implies
 *    full connectivity (all nodes can talk to all others).
 *
 * Parameters:
 *
 *    connectivity_matrix_t c - connectivity matrix of the cluster
 *
 * Returns:
 *
 *    int - 0 if there are disconnects in the cluster; 1 if it has full
 *    connectivity.
 *
 * Algorithm:
 *
 *    Checks to see if there is any live node in the cluster that cannot
 *    communicate to another live node in the cluster. Node i is
 *    considered alive if c[i,i] is set. Nodes i and j are deemed to
 *    be able to communicate if c[i,j] and c[j,i] are both set.
 *
 ************************************************************************/
_priv _resident int
connectivity_complete(connectivity_matrix_t c)
{
   node_t i, j;

   for (i = 0; i < (node_t) rgp->num_nodes; i++)
   {
      if (node_considered_alive(i))
      {
         for (j = 0; j < i; j++)
         {
            if (node_considered_alive(j) && !connected(i, j))
            {
               /* i and j are a pair of live nodes which are not
                  connected. Thus, there is at least one disconnect.
                  Return 0. */
               return(0);
            }
         }
      }
   }

   /* No disconnects found; return 1. */
   return(1);
}


/************************************************************************
 * find_all_fully_connected_groups
 * ===============================
 *
 * Description:
 *
 *    Function to find all fully connected groups in a graph specified
 *    by a connectivity matrix. An optional "selected_node" can be
 *    used to simplify the search in case of too large a number of
 *    possibilities. In that case, a fully-connected group that
 *    includes selected_node is returned.
 *
 * Parameters:
 *
 *    connectivity_matrix_t c -
 *       input : cluster's connectivity info
 *
 *    node_t selected_node -
 *       input : if there are too many potential groups, just find one
 *       that includes this node; if all groups can be listed, ignore this.
 *
 *    cluster_t groups[] -
 *       output: array of potential clusters
 *
 * Returns:
 *
 *    int - the number of groups made;  0 if no groups or other error
 *
 * Algorithm:
 *
 *    First the set of live nodes and the set of disconnects in the
 *    cluster are evaluated. Then, if the number of live nodes and
 *    disconnects indicates a potentially large number of
 *    possibilities, select_group_with_designated_node() is called to
 *    limit the search to a group including the specified node.
 *    Otherwise, prune() is called to get the list of all possible
 *    fully-connected groups.
 *
 ************************************************************************/
_priv _resident int
find_all_fully_connected_groups(
   connectivity_matrix_t   c,
   node_t                  selected_node,
   cluster_t               groups[])
{
   disconnect_array disconnects;
   cluster_t live_nodes;
   int num_livenodes = 0, num_disconnects = 0;
   node_t i, j;

   ClusterInit(live_nodes);
   for (i = 0; i < (node_t) rgp->num_nodes; i++)
   {
      if (node_considered_alive(i))
      {
         ClusterInsert(live_nodes, i);
         num_livenodes++;
         for (j = 0; j < i; j++)
         {
            if (node_considered_alive(j) && !connected(i, j))
            {
               /* i and j are a pair of live nodes which are not
                  connected. */
               disconnects[num_disconnects][0] = i;
               disconnects[num_disconnects][1] = j;
               num_disconnects++;
            }
         }
         if (too_many_groups(num_livenodes, num_disconnects))
         {
            RGP_TRACE( "RGP Too many dis",
                       num_livenodes,                           /* TRACE */
                       num_disconnects,                         /* TRACE */
                       0, 0 );                                  /* TRACE */
            /* There may be too many choices to consider in reasonable
             * time/space. Just return a fully-connected group that
             * includes the selected node.
             */
            return(select_group_with_designated_node(c,selected_node,groups));
         }
      }
   }

   if (num_livenodes == 0)
      return(0);
   else
      return(prune(disconnects, num_disconnects, live_nodes, groups));
}
/*---------------------------------------------------------------------------*/

#ifdef __cplusplus
}
#endif /* __cplusplus */


#if 0

History of changes to this file:
-------------------------------------------------------------------------
1995, December 13                                           F40:KSK0610          /*F40:KSK06102.2*/

This file is part of the portable Regroup Module used in the NonStop
Kernel (NSK) and Loosely Coupled UNIX (LCU) operating systems. There
are 10 files in the module - jrgp.h, jrgpos.h, wrgp.h, wrgpos.h,
srgpif.c, srgpos.c, srgpsm.c, srgputl.c, srgpcli.c and srgpsvr.c.
The last two are simulation files to test the Regroup Module on a
UNIX workstation in user mode with processes simulating processor nodes
and UDP datagrams used to send unacknowledged datagrams.

This file was first submitted for release into NSK on 12/13/95.
------------------------------------------------------------------------------
This change occurred on 19 Jan 1996                                              /*F40:MB06458.1*/
Changes for phase IV Sierra message system release. Includes:                    /*F40:MB06458.2*/
 - Some cleanup of the code                                                      /*F40:MB06458.3*/
 - Increment KCCB counters to count the number of setup messages and             /*F40:MB06458.4*/
   unsequenced messages sent.                                                    /*F40:MB06458.5*/
 - Fixed some bugs                                                               /*F40:MB06458.6*/
 - Disable interrupts before allocating broadcast sibs.                          /*F40:MB06458.7*/
 - Change per-packet-timeout to 5ms                                              /*F40:MB06458.8*/
 - Make the regroup and powerfail broadcast use highest priority                 /*F40:MB06458.9*/
   tnet services queue.                                                          /*F40:MB06458.10*/
 - Call the millicode backdoor to get the processor status from SP               /*F40:MB06458.11*/
 - Fixed expand bug in msg_listen_ and msg_readctrl_                             /*F40:MB06458.12*/
 - Added enhancement to msngr_sendmsg_ so that clients do not need               /*F40:MB06458.13*/
   to be unstoppable before calling this routine.                                /*F40:MB06458.14*/
 - Added new steps in the build file called                                      /*F40:MB06458.15*/
   MSGSYS_C - compiles all the message system C files                            /*F40:MB06458.16*/
   MSDRIVER - compiles all the MSDriver files                                    /*F40:MB06458.17*/
   REGROUP  - compiles all the regroup files                                     /*F40:MB06458.18*/
 - remove #pragma env libspace because we set it as a command line               /*F40:MB06458.19*/
   parameter.                                                                    /*F40:MB06458.20*/
-----------------------------------------------------------------------          /*F40:MB06458.21*/

#endif    /* 0 - change descriptions */