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