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