1: /********************************bit_mask.c************************************

  3: Author: Henry M. Tufo III

  5: e-mail: hmt@cs.brown.edu

  7: snail-mail:
  8: Division of Applied Mathematics
  9: Brown University
 10: Providence, RI 02912

 12: Last Modification:
 13: 11.21.97
 14: *********************************bit_mask.c***********************************/
 15: #include <../src/ksp/pc/impls/tfs/tfs.h>

 17: /*********************************bit_mask.c***********************************/
 18: PetscErrorCode PCTFS_bm_to_proc(char *ptr, PetscInt p_mask, PetscInt *msg_list)
 19: {
 20:   PetscInt i, tmp;

 22:   PetscFunctionBegin;
 23:   if (msg_list) {
 24:     /* low to high */
 25:     ptr += (p_mask - 1);
 26:     for (i = p_mask - 1; i >= 0; i--) {
 27:       tmp = BYTE * (p_mask - i - 1);
 28:       if (*ptr & BIT_0) {
 29:         *msg_list = tmp;
 30:         msg_list++;
 31:       }
 32:       if (*ptr & BIT_1) {
 33:         *msg_list = tmp + 1;
 34:         msg_list++;
 35:       }
 36:       if (*ptr & BIT_2) {
 37:         *msg_list = tmp + 2;
 38:         msg_list++;
 39:       }
 40:       if (*ptr & BIT_3) {
 41:         *msg_list = tmp + 3;
 42:         msg_list++;
 43:       }
 44:       if (*ptr & BIT_4) {
 45:         *msg_list = tmp + 4;
 46:         msg_list++;
 47:       }
 48:       if (*ptr & BIT_5) {
 49:         *msg_list = tmp + 5;
 50:         msg_list++;
 51:       }
 52:       if (*ptr & BIT_6) {
 53:         *msg_list = tmp + 6;
 54:         msg_list++;
 55:       }
 56:       if (*ptr & BIT_7) {
 57:         *msg_list = tmp + 7;
 58:         msg_list++;
 59:       }
 60:       ptr--;
 61:     }
 62:   }
 63:   PetscFunctionReturn(PETSC_SUCCESS);
 64: }

 66: /*********************************bit_mask.c***********************************/
 67: PetscInt PCTFS_ct_bits(char *ptr, PetscInt n)
 68: {
 69:   PetscInt i, tmp = 0;

 71:   for (i = 0; i < n; i++) {
 72:     if (*ptr & 128) tmp++;
 73:     if (*ptr & 64) tmp++;
 74:     if (*ptr & 32) tmp++;
 75:     if (*ptr & 16) tmp++;
 76:     if (*ptr & 8) tmp++;
 77:     if (*ptr & 4) tmp++;
 78:     if (*ptr & 2) tmp++;
 79:     if (*ptr & 1) tmp++;
 80:     ptr++;
 81:   }
 82:   return tmp;
 83: }

 85: /*********************************bit_mask.c***********************************/
 86: PetscInt PCTFS_div_ceil(PetscInt numer, PetscInt denom)
 87: {
 88:   if ((numer < 0) || (denom <= 0)) SETERRABORT(PETSC_COMM_SELF, PETSC_ERR_PLIB, "PCTFS_div_ceil() :: numer=%" PetscInt_FMT " ! >=0, denom=%" PetscInt_FMT " ! >0", numer, denom);
 89:   return PetscCeilInt(numer, denom);
 90: }

 92: /*********************************bit_mask.c***********************************/
 93: PetscInt PCTFS_len_bit_mask(PetscInt num_items)
 94: {
 95:   PetscInt rt_val, tmp;

 97:   PetscCheck(num_items >= 0, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Value Sent To PCTFS_len_bit_mask() Must be >= 0!");

 99:   rt_val = PetscCeilInt(num_items, BYTE);
100:   /* make multiple of sizeof PetscInt */
101:   if ((tmp = rt_val % sizeof(PetscInt))) rt_val += (sizeof(PetscInt) - tmp);
102:   return rt_val;
103: }

105: /*********************************bit_mask.c***********************************/
106: PetscErrorCode PCTFS_set_bit_mask(PetscInt *bm, PetscInt len, PetscInt val)
107: {
108:   PetscInt i, offset;
109:   char     mask = 1;
110:   char    *cptr;

112:   PetscFunctionBegin;
113:   PetscCheck(PCTFS_len_bit_mask(val) <= len, PETSC_COMM_SELF, PETSC_ERR_PLIB, "The Bit Mask Isn't That Large!");

115:   cptr = (char *)bm;

117:   offset = len / sizeof(PetscInt);
118:   for (i = 0; i < offset; i++) {
119:     *bm = 0;
120:     bm++;
121:   }

123:   offset = val % BYTE;
124:   for (i = 0; i < offset; i++) mask <<= 1;

126:   offset       = len - val / BYTE - 1;
127:   cptr[offset] = mask;
128:   PetscFunctionReturn(PETSC_SUCCESS);
129: }

131: /*********************************bit_mask.c***********************************/
132: PetscInt PCTFS_len_buf(PetscInt item_size, PetscInt num_items)
133: {
134:   PetscInt rt_val, tmp;

136:   rt_val = item_size * num_items;

138:   /*  double precision align for now ... consider page later */
139:   if ((tmp = (rt_val % (PetscInt)sizeof(double)))) rt_val += (sizeof(double) - tmp);
140:   return rt_val;
141: }