Actual source code: bitmask.c


  2: /********************************bit_mask.c************************************

  4: Author: Henry M. Tufo III

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

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

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

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

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

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

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

 86: /*********************************bit_mask.c***********************************/
 87: PetscInt PCTFS_div_ceil(PetscInt numer, PetscInt denom)
 88: {
 89:   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);
 90:   return (PetscCeilInt(numer, denom));
 91: }

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

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

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

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

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

116:   cptr = (char *)bm;

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

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

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

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

137:   rt_val = item_size * num_items;

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