Actual source code: bit_mask.c

  1: /*$Id: bit_mask.c,v 1.3 2001/04/10 19:37:38 bsmith Exp $*/

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

  6: Author: Henry M. Tufo III

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

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

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

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

 23: *********************************bit_mask.c***********************************/
 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 
108: ct_bits(register char *ptr, int n)
109: {
110:   register int i, tmp=0;


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

126:   return(tmp);
127: }



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

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

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

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



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

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

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

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

182:   return(rt_val);
183: }



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

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


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

206:   cptr = (char *) bm;

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

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

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



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

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

235:   rt_val = item_size * num_items;

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

241:   return(rt_val);
242: }