Actual source code: bit_mask.c

  2: /********************************bit_mask.c************************************
  3: SPARSE GATHER-SCATTER PACKAGE: bit_mask bss_malloc ivec error comm gs queue

  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 petsc.h
 24:  #include const.h
 25: #include "bit_mask.h"
 26:  #include error.h



 30: /********************************bit_mask.c************************************
 31: Function: bm_to_proc

 33: Input : 
 34: Output: 
 35: Return: 
 36: Description: 
 37: *********************************bit_mask.c***********************************/
 38: void 
 39: bm_to_proc(register char *ptr, int p_mask, register int *msg_list)
 40: {
 41:   register int i, tmp;

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

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

 94:     }
 95: }



 99: /********************************bit_mask.c************************************
100: Function: ct_bits()

102: Input : 
103: Output: 
104: Return: 
105: Description: 
106: *********************************bit_mask.c***********************************/
107: int ct_bits(register char *ptr, int n)
108: {
109:   register int i, tmp=0;


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

125:   return(tmp);
126: }



130: /********************************bit_mask.c************************************
131: Function: len_buf()

133: Input : 
134: Output: 
135: Return: 
136: Description:
137: *********************************bit_mask.c***********************************/
138: int
139: div_ceil(register int numer, register int denom)
140: {
141:   register int rt_val;

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

146:   /* if integer division remainder then increment */
147:   rt_val = numer/denom;
148:   if (numer%denom)
149:     {rt_val++;}
150: 
151:   return(rt_val);
152: }



156: /********************************bit_mask.c************************************
157: Function: len_bit_mask()

159: Input : 
160: Output: 
161: Return: 
162: Description:
163: *********************************bit_mask.c***********************************/
164: int
165: len_bit_mask(register int num_items)
166: {
167:   register int rt_val, tmp;

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

172:   /* mod BYTE ceiling function */
173:   rt_val = num_items/BYTE;
174:   if (num_items%BYTE)
175:     {rt_val++;}
176: 
177:   /* make mults of sizeof int */
178:   if ((tmp=rt_val%INT_LEN))
179:     {rt_val+=(INT_LEN-tmp);}

181:   return(rt_val);
182: }



186: /********************************bit_mask.c************************************
187: Function: set_bit_mask()

189: Input : 
190: Output: 
191: Return:
192: Description: 
193: *********************************bit_mask.c***********************************/
194: void
195: set_bit_mask(register int *bm, int len, int val)
196: {
197:   register int i, offset;
198:   register char mask = 1;
199:   char *cptr;


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

205:   cptr = (char *) bm;

207:   offset = len/INT_LEN;
208:   for (i=0;i<offset;i++)
209:     {*bm=0; bm++;}

211:   offset = val%BYTE;
212:   for (i=0;i<offset;i++)
213:     {mask <<= 1;}

215:   offset = len - val/BYTE - 1;
216:   cptr[offset] = mask;
217: }



221: /********************************bit_mask.c************************************
222: Function: len_buf()

224: Input : 
225: Output: 
226: Return: 
227: Description: 
228: *********************************bit_mask.c***********************************/
229: int
230: len_buf(int item_size, int num_items)
231: {
232:   register int rt_val, tmp;

234:   rt_val = item_size * num_items;

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

240:   return(rt_val);
241: }