Actual source code: bit_mask.c

  1: #define PETSCKSP_DLL

  3: /********************************bit_mask.c************************************

  5: Author: Henry M. Tufo III

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

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

 14: Last Modification: 
 15: 11.21.97
 16: *********************************bit_mask.c***********************************/

 18: /********************************bit_mask.c************************************
 19: File Description:
 20: -----------------

 22: *********************************bit_mask.c***********************************/
 23:  #include src/ksp/pc/impls/tfs/tfs.h


 26: /********************************bit_mask.c************************************
 27: Function: bm_to_proc

 29: Input : 
 30: Output: 
 31: Return: 
 32: Description: 
 33: *********************************bit_mask.c***********************************/
 34: void 
 35: bm_to_proc( char *ptr, int p_mask,  int *msg_list)
 36: {
 37:    int i, tmp;

 39:   if (msg_list)
 40:     {
 41:       /* low to high */
 42:       ptr+=(p_mask-1);
 43:       for (i=p_mask-1;i>=0;i--)
 44:         {
 45:           tmp = BYTE*(p_mask-i-1);
 46:           if (*ptr&BIT_0)
 47:             {*msg_list = tmp; msg_list++;}
 48:           if (*ptr&BIT_1)
 49:             {*msg_list = tmp+1; msg_list++;}
 50:           if (*ptr&BIT_2)
 51:             {*msg_list = tmp+2; msg_list++;}
 52:           if (*ptr&BIT_3)
 53:             {*msg_list = tmp+3; msg_list++;}
 54:           if (*ptr&BIT_4)
 55:             {*msg_list = tmp+4; msg_list++;}
 56:           if (*ptr&BIT_5)
 57:             {*msg_list = tmp+5; msg_list++;}
 58:           if (*ptr&BIT_6)
 59:             {*msg_list = tmp+6; msg_list++;}
 60:           if (*ptr&BIT_7)
 61:             {*msg_list = tmp+7; msg_list++;}
 62:           ptr --;
 63:         }

 65:       /* high to low */
 66:       /*
 67:       for (i=0;i<p_mask;i++)
 68:         {
 69:           tmp = BYTE*(p_mask-i-1);
 70:           if (*ptr&128) 
 71:             {*msg_list = tmp+7; msg_list++;}
 72:           if (*ptr&64)
 73:             {*msg_list = tmp+6; msg_list++;}
 74:           if (*ptr&32)
 75:             {*msg_list = tmp+5; msg_list++;}
 76:           if (*ptr&16)
 77:             {*msg_list = tmp+4; msg_list++;}
 78:           if (*ptr&8) 
 79:             {*msg_list = tmp+3; msg_list++;}
 80:           if (*ptr&4) 
 81:             {*msg_list = tmp+2; msg_list++;}
 82:           if (*ptr&2) 
 83:             {*msg_list = tmp+1; msg_list++;}
 84:           if (*ptr&1) 
 85:             {*msg_list = tmp; msg_list++;}
 86:           ptr ++;
 87:         }
 88:       */

 90:     }
 91: }



 95: /********************************bit_mask.c************************************
 96: Function: ct_bits()

 98: Input : 
 99: Output: 
100: Return: 
101: Description: 
102: *********************************bit_mask.c***********************************/
103: int ct_bits( char *ptr, int n)
104: {
105:    int i, tmp=0;


108:   for(i=0;i<n;i++)
109:     {
110:       if (*ptr&128) {tmp++;}
111:       if (*ptr&64)  {tmp++;}
112:       if (*ptr&32)  {tmp++;}
113:       if (*ptr&16)  {tmp++;}
114:       if (*ptr&8)   {tmp++;}
115:       if (*ptr&4)   {tmp++;}
116:       if (*ptr&2)   {tmp++;}
117:       if (*ptr&1)   {tmp++;}
118:       ptr++;
119:     }

121:   return(tmp);
122: }



126: /********************************bit_mask.c************************************
127: Function: len_buf()

129: Input : 
130: Output: 
131: Return: 
132: Description:
133: *********************************bit_mask.c***********************************/
134: int
135: div_ceil( int numer,  int denom)
136: {
137:    int rt_val;

139:   if ((numer<0)||(denom<=0))
140:     {error_msg_fatal("div_ceil() :: numer=%D ! >=0, denom=%D ! >0",numer,denom);}

142:   /* if integer division remainder then increment */
143:   rt_val = numer/denom;
144:   if (numer%denom)
145:     {rt_val++;}
146: 
147:   return(rt_val);
148: }



152: /********************************bit_mask.c************************************
153: Function: len_bit_mask()

155: Input : 
156: Output: 
157: Return: 
158: Description:
159: *********************************bit_mask.c***********************************/
160: int
161: len_bit_mask( int num_items)
162: {
163:    int rt_val, tmp;

165:   if (num_items<0)
166:     {error_msg_fatal("Value Sent To len_bit_mask() Must be >= 0!");}

168:   /* mod BYTE ceiling function */
169:   rt_val = num_items/BYTE;
170:   if (num_items%BYTE)
171:     {rt_val++;}
172: 
173:   /* make mults of sizeof int */
174:   if ((tmp=rt_val%sizeof(PetscInt)))
175:     {rt_val+=(sizeof(PetscInt)-tmp);}

177:   return(rt_val);
178: }



182: /********************************bit_mask.c************************************
183: Function: set_bit_mask()

185: Input : 
186: Output: 
187: Return:
188: Description: 
189: *********************************bit_mask.c***********************************/
190: void
191: set_bit_mask( int *bm, int len, int val)
192: {
193:    int i, offset;
194:    char mask = 1;
195:   char *cptr;


198:   if (len_bit_mask(val)>len)
199:     {error_msg_fatal("The Bit Mask Isn't That Large!");}

201:   cptr = (char *) bm;

203:   offset = len/sizeof(PetscInt);
204:   for (i=0;i<offset;i++)
205:     {*bm=0; bm++;}

207:   offset = val%BYTE;
208:   for (i=0;i<offset;i++)
209:     {mask <<= 1;}

211:   offset = len - val/BYTE - 1;
212:   cptr[offset] = mask;
213: }



217: /********************************bit_mask.c************************************
218: Function: len_buf()

220: Input : 
221: Output: 
222: Return: 
223: Description: 
224: *********************************bit_mask.c***********************************/
225: int
226: len_buf(int item_size, int num_items)
227: {
228:    int rt_val, tmp;

230:   rt_val = item_size * num_items;

232:   /*  double precision align for now ... consider page later */
233:   if ((tmp = (rt_val%(int)sizeof(double))))
234:     {rt_val += (sizeof(double) - tmp);}

236:   return(rt_val);
237: }