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: }