OpenAtom  Version1.5a
FindProcessor.C
Go to the documentation of this file.
1 /** \file FindProcessor.C
2  * Author: Abhinav S Bhatele
3  * Date Created: November 30th, 2005
4  * Topologies supported: 3D Mesh (on BlueGene/L)
5  * 3D Torus (on Bluegene/L): Co-processor mode
6  * 3D Torus (on Bluegene/L): Virtual NOde mode
7  */
8 
9 #include "FindProcessor.h"
10 #include <charm++.h>
11 
12 
13 
14 FindProcessor::FindProcessor()
15 {
16  negXL=negYL=negZL=posXL=posYL=posZL=0;
17  distance=0;
18  for(int i=0; i<3;i++)
19  {
20  start[i]=0;
21  next[i]=0;
22  }
23 }
24 
25 
26 FindProcessor::FindProcessor(int a[])
27 {
28  negXL=negYL=negZL=posXL=posYL=posZL=0;
29  distance=0;
30  for(int i=0; i<3;i++)
31  start[i]=a[i];
32 }
33 
34 void FindProcessor::init()
35 {
36  negXL=negYL=negZL=posXL=posYL=posZL=0;
37  distance=0;
38  if(nopX%2==0)
39  negXL = nopX/2;
40  else
41  negXL = nopX/2 + 1;
42  if(nopY%2==0)
43  negYL = nopY/2;
44  else
45  negYL = nopY/2 + 1;
46  if(nopZ%2==0)
47  negZL = nopZ/2;
48  else
49  negZL = nopZ/2 + 1;
50  ///out<<"actual -> "<<negXL<<" "<<negYL<<" "<<negZL<<"\n";
51  /*int negXL=(int)(ceil(nopX/2.0));
52  int negYL=(int)(ceil(nopY/2.0));
53  int negZL=(int)(ceil(nopZ/2.0));*/
54 
55  posXL=nopX/2 + 1;
56  posYL=nopY/2 + 1;
57  posZL=nopZ/2 + 1;
58 }
59 
60 void FindProcessor::findNext(int a[])
61 {
62  if(a[0]==0 && a[1]==0 && a[2]==0)
63  {
64  next[2]=1;
65  cout<<"-------------------------\n";
66  cout<<"Distance "<<next[2]<<" starting\n";
67  cout<<"-------------------------\n";
68  printing(0, 0, 1);
69  }
70  else
71  {
72  if(a[0]<=0 && a[1]<=0 && a[2]<=0)
73  {
74  for(int i=0; i<3;i++)
75  a[i]=-1*a[i];
76 
77  if(a[2]>0)
78  {
79  next[0]=a[0];
80  next[1]=a[1]+1;
81  next[2]=a[2]-1;
82  printing(next[0], next[1], next[2]);
83  }
84  else
85  {
86  if(a[1]>0)
87  {
88  next[0]=a[0]+1;
89  next[1]=0;
90  next[2]=a[1]-1;
91  printing(next[0], next[1], next[2]);
92  }
93  else
94  {
95  next[0]=0;
96  next[1]=0;
97  next[2]=a[0]+1;
98  cout<<"-------------------------\n";
99  cout<<"Distance "<<next[2]<<" starting\n";
100  cout<<"-------------------------\n";
101  printing(next[0], next[1], next[2]);
102  }
103  }
104  }
105  else
106  {
107  if(a[2]>0)
108  {
109  next[0]=a[0];
110  next[1]=a[1];
111  next[2]=a[2]*-1;
112  printing(next[0], next[1], next[2]);
113  }
114  else
115  {
116  if(a[1]>0)
117  {
118  next[0]=a[0];
119  next[1]=a[1]*-1;
120  next[2]=a[2]*-1;
121  printing(next[0], next[1], next[2]);
122  }
123  else
124  {
125  next[0]=a[0]*-1;
126  next[1]=a[1]*-1;
127  next[2]=a[2]*-1;
128  printing(next[0], next[1], next[2]);
129  }
130  }
131  }
132  }
133 }
134 
135 int FindProcessor::findNextInMIter(int a[])
136 {
137  if(a[0]==0 && a[1]==0 && a[2]==0)
138  {
139  next[2]=1;
140  ///out<<"-------------------------\n";
141  ///out<<"Distance "<<next[2]<<" starting\n";
142  ///out<<"-------------------------\n";
143  //printing(0, 0, 1);
144  }
145  else
146  {
147  if(a[2]>0)
148  {
149  next[0]=a[0];
150  next[1]=a[1]+1;
151  next[2]=a[2]-1;
152  if(next[0]>=nopZ || next[1]>=nopY || next[2]>=nopX)
153  {
154  for(int i=0;i<3;i++)
155  start[i]=next[i];
156  return 2;
157  }
158  //printing(next[0], next[1], next[2]);
159  }
160  else
161  {
162  if(a[1]>0)
163  {
164  next[0]=a[0]+1;
165  next[1]=0;
166  next[2]=a[1]-1;
167  if(next[0]>=nopZ || next[1]>=nopY || next[2]>=nopX)
168  {
169  for(int i=0;i<3;i++)
170  start[i]=next[i];
171  return 2;
172  }
173  //printing(next[0], next[1], next[2]);
174  }
175  else
176  {
177  next[0]=0;
178  next[1]=0;
179  next[2]=a[0]+1;
180  if(next[0]>=nopZ || next[1]>=nopY || next[2]>=nopX)
181  {
182  for(int i=0;i<3;i++)
183  start[i]=next[i];
184  return 2;
185  }
186  ///out<<"-------------------------\n";
187  ///out<<"Distance "<<next[2]<<" starting\n";
188  ///out<<"-------------------------\n";
189  //printing(next[0], next[1], next[2]);
190  }
191  }
192 
193  }
194  count++;
195  return 1;
196 }
197 
198 int FindProcessor::findNextInMesh(int a[])
199 {
200  int ret = findNextInMIter(a);
201  if(count == nopX*nopY*nopZ)
202  {
203  cout<<"-------------------------\n";
204  cout<<"No more processors left\n";
205  cout<<"-------------------------\n";
206  CkAbort("inconsistent no. of chares and processors\n");
207  return 0;
208  }
209  if(ret==1)
210  return ret;
211  else
212  {
213  ret=findNextInMIter(start);
214  while(ret==2)
215  {
216  ret=findNextInMIter(start);
217  }
218  return ret;
219  }
220 }
221 
222 int FindProcessor::findNextIter(int a[])
223 {
224  int newa[3];
225  CkAssert(posXL>0);
226  if(count==nopX*nopY*nopZ)
227  {
228  cout<<"-------------------------\n";
229  cout<<"No more processors left\n";
230  cout<<"-------------------------\n";
231  CkAbort("inconsistent no. of chares and processors\n");
232  return 0;
233  }
234 
235  if(a[0]==0 && a[1]==0 && a[2]==0)
236  {
237  next[2]=1;
238  distance=1;
239  if(next[2]>=posXL)
240  {
241  for(int i=0;i<3;i++)
242  {
243  newa[i]=next[i];
244  start[i]=next[i];
245  }
246  //printing_sp(start[0], start[1], start[2]);
247  return 2;
248  }
249  else
250  {
251  ///out<<"-------------------------\n";
252  ///out<<"Distance "<<distance<<" starting\n";
253  ///out<<"-------------------------\n";
254  //printing(0, 0, 1);
255  }
256  }
257  else
258  {
259  if(a[0]<=0 && a[1]<=0 && a[2]<=0)
260  {
261  for(int i=0; i<3;i++)
262  a[i]=-1*a[i];
263 
264  if(a[2]>0)
265  {
266  next[0]=a[0];
267  next[1]=a[1]+1;
268  next[2]=a[2]-1;
269  if(abs(next[0])>=posZL || abs(next[1])>=posYL || abs(next[2])>=posXL)
270  {
271  for(int i=0;i<3;i++)
272  {
273  newa[i]=next[i];
274  start[i]=next[i];
275  }
276  //printing_sp(start[0], start[1], start[2]);
277  return 2;
278  }
279  else
280  {
281  if(next[2]<0)
282  next[2]=next[2]+nopX;
283  if(next[1]<0)
284  next[1]=next[1]+nopY;
285  if(next[0]<0)
286  next[0]=next[0]+nopZ;
287  }
288  }
289  else
290  {
291  if(a[1]>0)
292  {
293  next[0]=a[0]+1;
294  next[1]=0;
295  next[2]=a[1]-1;
296  if(abs(next[0])>=posZL || abs(next[1])>=posYL || abs(next[2])>=posXL)
297  {
298  for(int i=0;i<3;i++)
299  {
300  start[i]=next[i];
301  newa[i]=next[i];
302  }
303  //printing_sp(start[0], start[1], start[2]);
304  return 2;
305  }
306  else
307  {
308  if(next[2]<0)
309  next[2]=next[2]+nopX;
310  if(next[1]<0)
311  next[1]=next[1]+nopY;
312  if(next[0]<0)
313  next[0]=next[0]+nopZ;
314  }
315  }
316  else
317  {
318  next[0]=0;
319  next[1]=0;
320  next[2]=a[0]+1;
321  if(abs(next[0])>=posZL || abs(next[1])>=posYL || abs(next[2])>=posXL)
322  {
323  distance=distance+1;
324  ///out<<"-------------------------\n";
325  ///out<<"Distance "<<distance<<" starting\n";
326  ///out<<"-------------------------\n";
327  for(int i=0;i<3;i++)
328  {
329  start[i]=next[i];
330  newa[i]=next[i];
331  }
332  //printing_sp(start[0], start[1], start[2]);
333  return 2;
334  }
335  else
336  {
337  if(next[2]<0)
338  next[2]=next[2]+nopX;
339  if(next[1]<0)
340  next[1]=next[1]+nopY;
341  if(next[0]<0)
342  next[0]=next[0]+nopZ;
343  }
344  }
345  }
346  }
347  else
348  {
349  if(a[2]>0)
350  {
351  next[0]=a[0];
352  next[1]=a[1];
353  next[2]=a[2]*-1;
354  if(compare(next[0], posZL, negZL) || compare(next[1], posYL, negYL) || compare(next[2], posXL, negXL))
355  {
356  for(int i=0;i<3;i++)
357  {
358  start[i]=next[i];
359  newa[i]=next[i];
360  }
361  //printing_sp(start[0], start[1], start[2]);
362  return 2;
363  }
364  else
365  {
366  if(next[2]<0)
367  next[2]=next[2]+nopX;
368  if(next[1]<0)
369  next[1]=next[1]+nopY;
370  if(next[0]<0)
371  next[0]=next[0]+nopZ;
372  }
373  }
374  else
375  {
376  if(a[1]>0)
377  {
378  next[0]=a[0];
379  next[1]=a[1]*-1;
380  next[2]=a[2]*-1;
381  if(compare(next[0], posZL, negZL) || compare(next[1], posYL, negYL) || compare(next[2], posXL, negXL))
382  {
383  for(int i=0;i<3;i++)
384  {
385  start[i]=next[i];
386  newa[i]=next[i];
387  }
388  //printing_sp(start[0], start[1], start[2]);
389  return 2;
390  }
391  else
392  {
393  if(next[2]<0)
394  next[2]=next[2]+nopX;
395  if(next[1]<0)
396  next[1]=next[1]+nopY;
397  if(next[0]<0)
398  next[0]=next[0]+nopZ;
399  }
400  }
401  else
402  {
403  next[0]=a[0]*-1;
404  next[1]=a[1]*-1;
405  next[2]=a[2]*-1;
406  if(compare(next[0], posZL, negZL) || compare(next[1], posYL, negYL) || compare(next[2], posXL, negXL))
407  {
408  for(int i=0;i<3;i++)
409  {
410  start[i]=next[i];
411  newa[i]=next[i];
412  }
413  //printing_sp(start[0], start[1], start[2]);
414  return 2;
415  }
416  else
417  {
418  if(next[2]<0)
419  next[2]=next[2]+nopX;
420  if(next[1]<0)
421  next[1]=next[1]+nopY;
422  if(next[0]<0)
423  next[0]=next[0]+nopZ;
424  }
425  }
426  }
427  }
428  //printing(next[0], next[1], next[2]);
429  }
430  count++; //add near all other prints
431  return 1;
432 }
433 
434 int FindProcessor::findNextInTorus(int a[])
435 {
436  int ret = findNextIter(a);
437  while(ret==2)
438  {
439  ret=findNextIter(start);
440  }
441  return ret;
442 }
443 
444 int FindProcessor::findNextInTorusV(int t, int a[])
445 {
446  int ret;
447  if(t==0)
448  {
449  w=1;
450  //printing(w, next[0], next[1], next[2]);
451  return 1;
452  }
453  else
454  {
455  w=0;
456  if(count==nopX*nopY*nopZ) {
457  cout<<"-------------------------\n";
458  cout<<"No more processors left\n";
459  cout<<"-------------------------\n";
460  CkAbort("inconsistent no. of chares and processors\n");
461  return 0;
462  }
463 
464  ret = findNextIter(a);
465  while(ret==2)
466  {
467  ret=findNextIter(start);
468  }
469  return ret;
470  }
471 }
472 
473 int FindProcessor::compare(int n, int a, int b)
474 {
475  if(n>=0)
476  if(n>=a)
477  return 1;
478  else
479  return 0;
480  else
481  if(abs(n)>=b)
482  return 1;
483  else
484  return 0;
485 }
486 
487 /* Various functions which can be used for printing the processor coordinates
488  * printSome(int) - print the no. of processors the user wishes
489  * printing(int, int, int) - print for bluegene CO mode
490  * printing_sp(int, int, int) - for debugging purposes
491  * printing(int, int, int, int) - print for bluegene VN mode
492  */
493 
494 void FindProcessor::printSome(int n)
495 {
496  int val;
497  int array[3];
498  if(option==1)
499  findNext(start);
500  if(option==2)
501  findNextInMesh(start);
502  if(option==3)
503  {
504  ///ount=1;
505  if(start[2]>nopX/2)
506  array[2]=start[2]-nopX;
507  else
508  array[2]=start[2];
509  if(start[1]>nopY/2)
510  array[1]=start[1]-nopY;
511  else
512  array[1]=start[1];
513  if(start[0]>nopZ/2)
514  array[0]=start[0]-nopZ;
515  else
516  array[0]=start[0];
517  ///out<<"check: ";
518  //printing(array[0],array[1],array[2]);
519  val=findNextInTorus(array);
520  }
521  if(option==4)
522  {
523  if(start[2]>nopX/2)
524  array[2]=start[2]-nopX;
525  else
526  array[2]=start[2];
527  if(start[1]>nopY/2)
528  array[1]=start[1]-nopY;
529  else
530  array[1]=start[1];
531  if(start[0]>nopZ/2)
532  array[0]=start[0]-nopZ;
533  else
534  array[0]=start[0];
535  ///out<<"check: ";
536  //printing(array[0],array[1],array[2]);
537  val=findNextInTorusV(w, array);
538  }
539  while(n>0)
540  {
541  for(int i=0;i<3;i++)
542  start[i]=next[i];
543  if(option==1)
544  findNext(start);
545  if(option==2)
546  findNextInMesh(start);
547  if(option==3)
548  {
549  if(val!=0)
550  {
551  if(start[2]>nopX/2)
552  array[2]=start[2]-nopX;
553  else
554  array[2]=start[2];
555  if(start[1]>nopY/2)
556  array[1]=start[1]-nopY;
557  else
558  array[1]=start[1];
559  if(start[0]>nopZ/2)
560  array[0]=start[0]-nopZ;
561  else
562  array[0]=start[0];
563  ///out<<"check: ";
564  //printing(array[0],array[1],array[2]);
565  val=findNextInTorus(array);
566  /*if(count==nopX*nopY*nopZ-1)
567  return;*/
568  }
569  }
570  if(option==4)
571  {
572  if(val!=0)
573  {
574  if(start[2]>nopX/2)
575  array[2]=start[2]-nopX;
576  else
577  array[2]=start[2];
578  if(start[1]>nopY/2)
579  array[1]=start[1]-nopY;
580  else
581  array[1]=start[1];
582  if(start[0]>nopZ/2)
583  array[0]=start[0]-nopZ;
584  else
585  array[0]=start[0];
586  ///out<<"check: ";
587  //printing(array[0],array[1],array[2]);
588  val=findNextInTorusV(w, array);
589  }
590  }
591  n--;
592  }
593 }
594 
595 void FindProcessor::printing(int a, int b, int c)
596 {
597  if(count<10)
598  cout<<" "<<count<<". ";
599  else if(count<100)
600  cout<<" "<<count<<". ";
601  else
602  cout<<count<<". ";
603  if(a<0)
604  cout<<a;
605  else
606  cout<<" "<<a;
607  if(b<0)
608  cout<<" "<<b;
609  else
610  cout<<" "<<b;
611  if(c<0)
612  cout<<" "<<c<<"\n";
613  else
614  cout<<" "<<c<<"\n";
615  ///ount++; needs to be placed in other two functions!
616 }
617 
618 void FindProcessor::printing_sp(int a, int b, int c)
619 {
620  if(a<0)
621  cout<<a;
622  else
623  cout<<" "<<a;
624  if(b<0)
625  cout<<" "<<b;
626  else
627  cout<<" "<<b;
628  if(c<0)
629  cout<<" "<<c<<"\n";
630  else
631  cout<<" "<<c<<"\n";
632 }
633 
634 void FindProcessor::printing(int w, int a, int b, int c)
635 {
636  if(count<10)
637  cout<<" "<<count<<". ";
638  else if(count<100)
639  cout<<" "<<count<<". ";
640  else
641  cout<<count<<". ";
642  if(w<0)
643  cout<<w;
644  else
645  cout<<" "<<w;
646  if(a<0)
647  cout<<" "<<a;
648  else
649  cout<<" "<<a;
650  if(b<0)
651  cout<<" "<<b;
652  else
653  cout<<" "<<b;
654  if(c<0)
655  cout<<" "<<c<<"\n";
656  else
657  cout<<" "<<c<<"\n";
658  ///ount++; needs to be placed in other two functions!
659 }
660 
661 /* int main which can be used for debugging
662  * functions in this file
663 
664 int main(int argc, char*argv[])
665 {
666  FindProcessor fp=FindProcessor();
667  if(strcmp(argv[1],"-3Dmesh")==0)
668  fp.option=1;
669  if(strcmp(argv[1],"-Bluegene")==0)
670  fp.option=2;
671  for(int i=2;i<5;i++)
672  fp.start[i-2]=atoi(argv[i]);
673  if(strcmp(argv[1],"-Torus")==0)
674  {
675  fp.option=3;
676  fp.nopX=atoi(argv[2]);
677  fp.nopY=atoi(argv[3]);
678  fp.nopZ=atoi(argv[4]);
679  for(int i=5;i<8;i++)
680  fp.start[i-5]=atoi(argv[i]);
681  }
682  if(strcmp(argv[1],"-TorusV")==0)
683  {
684  fp.option=4;
685  fp.nopX=atoi(argv[2]);
686  fp.nopY=atoi(argv[3]);
687  fp.nopZ=atoi(argv[4]);
688  fp.w=atoi(argv[5]);
689  for(int i=6;i<9;i++)
690  fp.start[i-6]=atoi(argv[i]);
691  }
692  fp.printSome(250);
693  //fp.findNext(fp.start);
694  //fp.findNextInMesh(fp.start);
695  //sfp.findNextInTorus(fp.start);
696 } //end main
697 
698  *
699  */
700 
701 
FindProcessor.h
Author: Abhinav S Bhatele Date Created: November 30th, 2005 Finds the nearest processor from a given ...
FindProcessor::printing
void printing(int a, int b, int c)
Definition: FindProcessor.C:595
FindProcessor::printSome
void printSome(int n)
Definition: FindProcessor.C:494
FindProcessor::findNextInMIter
int findNextInMIter(int a[])
Definition: FindProcessor.C:135
FindProcessor::findNextIter
int findNextIter(int a[])
Definition: FindProcessor.C:222