Remove unused headers from an old program, making a warning disappear in the
[charm.git] / examples / bigsim / emulator / littleMD / bgMD.C
1 /* File                 : bgMD.C 
2  * Author               : Arun Singla, Neelam Saboo, Joshua Unger,
3  *                        Gengbin Zheng
4  * Version              : 1.0: 3/24/2001
5  *                        2.0: 3/27/2001 - make this an actual working version 
6  *                             on converse bluegene by Gengbin Zheng
7  *
8  * Description  : Sample application for Blue Gene emulator (converse version)
9  *                                Prototype Molecular Dynamics: LittleMD
10  * Note                 : The program is converse-bluegene version of 
11  *                        charm-bluegene version written previously.
12 *******************************************************************************/
13
14 #include "blue.h"
15 #include "bgMD.h"
16
17 int sendCoordID;
18 int storeCoordID;
19 int retrieveForcesID;
20 int reduceID;
21
22 double startTime;
23
24 void BgEmulatorInit(int argc, char **argv) 
25 {
26   CmiPrintf("Initializing littleMD\n");
27
28   if (argc < 6) {
29     CmiPrintf("Usage: bgMD <x> <y> <z> <numCommTh> <numWorkTh>\n");
30     BgShutdown();
31   }
32   
33   /* set machine configuration */
34   BgSetSize(atoi(argv[1]), atoi(argv[2]), atoi(argv[3]));
35   BgSetNumCommThread(atoi(argv[4]));
36   BgSetNumWorkThread(atoi(argv[5]));
37
38 }
39
40 void BgNodeStart(int argc, char **argv)
41 {
42   /* register handlers */
43   sendCoordID      = BgRegisterHandler(sendCoord);
44   storeCoordID     = BgRegisterHandler(storeCoord);
45   retrieveForcesID = BgRegisterHandler(retrieveForces);
46   reduceID         = BgRegisterHandler(reduce);
47
48   int x, y, z;
49   BgGetMyXYZ(&x, &y, &z);
50   //CmiPrintf("BgNodeStart [%d,%d,%d]\n", x, y, z);
51
52   int sX, sY, sZ;
53   BgGetSize(&sX, &sY, &sZ);
54
55   /* Initialize simulation space  */
56   SimParams *spData = new SimParams;
57   // spData->setParams270K();
58   // spData->setParams40K();
59    spData->setParamsDebug();
60
61   double pdx = spData->max_x - spData->min_x;
62   double pdy = spData->max_y - spData->min_y;
63   double pdz = spData->max_z - spData->min_z;
64
65   spData->cell_dim_x = 1 + (int)(pdx / (spData->cutoff + spData->margin));
66   spData->cell_dim_y = 1 + (int)(pdy / (spData->cutoff + spData->margin));
67   spData->cell_dim_z = 1 + (int)(pdz / (spData->cutoff + spData->margin));
68   spData->total_cells = spData->cell_dim_x * spData->cell_dim_y * spData->cell_dim_z;
69
70   // CmiPrintf("BgNodeStart [%d,%d,%d] SimParams intialized %d %d %d\n", x, y, z, spData->cell_dim_x, spData->cell_dim_y, spData->cell_dim_z);
71
72   // Initialize cells per Blue Gene Node
73   // Find initial(x1, y1, z1) and final(x2, y2, z2) coordinates of cells mapped
74   //    to each node
75   // If the number of nodes exceeds the number of cells in any dimension, 
76   //    make a one-to-one mapping (Some Blue Gene nodes might be ununsed if 
77   //    simulation space is too small)
78   // Find number of cells mapped (x2-x1+1)*(y2-y1+1)*(z2-z1+1) to each node
79   
80   int cellsNodeX = spData->cell_dim_x <= sX ? 1 : spData->cell_dim_x / sX;
81   int cellsNodeY = spData->cell_dim_y <= sY ? 1 : spData->cell_dim_y / sY;
82   int cellsNodeZ = spData->cell_dim_z <= sZ ? 1 : spData->cell_dim_z / sZ;
83
84 //CmiPrintf("%d %d %d cellsNodeX:%d cellsNodeY:%d cellsNodeZ:%d\n", spData->cell_dim_x, spData->cell_dim_y, spData->cell_dim_z,cellsNodeX,cellsNodeY,cellsNodeZ);
85
86   int numCellMapped = 0;
87   int x1, y1, z1, x2, y2, z2;
88   if(x<spData->cell_dim_x && y<spData->cell_dim_y && z<spData->cell_dim_z)
89   {
90     x1 = cellsNodeX * x;
91     y1 = cellsNodeY * y;
92     z1 = cellsNodeZ * z;
93     
94     x2 = x==sX-1 ? (spData->cell_dim_x - 1) : (cellsNodeX*(x+1)-1);
95     y2 = y==sY-1 ? (spData->cell_dim_y - 1) : (cellsNodeY*(y+1)-1);
96     z2 = z==sZ-1 ? (spData->cell_dim_z - 1) : (cellsNodeZ*(z+1)-1);
97
98     numCellMapped = (x2-x1+1)*(y2-y1+1)*(z2-z1+1);
99     if(numCellMapped<0) {
100         CmiPrintf("Error> Number of cells mapped to Node [%d,%d,%d] is less than 0\n", x, y, z);
101         CmiAbort("\n");
102     }
103   }
104
105   // CmiPrintf("Mapping to Node [%d,%d,%d], [%d,%d,%d] to [%d,%d,%d] cells %d\n", x, y, z, x1, y1, z1, x2, y2, z2, numCellMapped);
106
107   CellData *cellData = new CellData[numCellMapped];
108
109   /* Store Neighbour Information for each Blue Gene Node, 
110    * If no cells are mapped to this node, don't use it.
111    */
112   if(numCellMapped>0)
113   {
114     int cellIndex = 0;
115     int neighborCount;
116     for(int i=x1; i<=x2; i++)
117      for(int j=y1; j<=y2; j++)
118       for(int k=z1; k<=z2; k++)
119       {
120         neighborCount = 0;
121
122         cellData[cellIndex].myCoord = CellCoord(i,j,k);
123         cellData[cellIndex].firstStep = true;
124         
125         //Initialize the cell
126         cellData[cellIndex].myCell = new Cell;
127         init_cell(cellData[cellIndex].myCell, i, j, k, spData);
128
129         //find the neighbors
130         //more: scope of optimization
131         cellData[cellIndex].neighborCoord = new CellCoord[(2*DISTANCE+1)*(2*DISTANCE+1)*(2*DISTANCE+1)];
132         int nx, ny, nz;
133         for(int l = -DISTANCE; l <= DISTANCE; l++)
134          for(int m = -DISTANCE; m <= DISTANCE; m++)
135           for(int n = -DISTANCE; n <= DISTANCE; n++)
136           {
137            nx = i + l ;
138            ny = j + m ;
139            nz = k + n ;
140
141            if ((nx < spData->cell_dim_x && nx >= 0) && 
142                (ny < spData->cell_dim_y && ny >= 0) &&
143                (nz < spData->cell_dim_z && nz >= 0) &&
144                !(l==0 && m==0 && n==0)) //<- you aren't your own neighbor
145            {
146                 CellCoord* cd = &cellData[cellIndex].neighborCoord[neighborCount];
147                 cd->x = nx;
148                 cd->y = ny;
149                 cd->z = nz;
150                 neighborCount++; 
151            }
152          }
153
154          cellData[cellIndex].neighborCount = neighborCount;
155          cellData[cellIndex].myPotEnergy = 0.0;
156          cellData[cellIndex].myKinEnergy = 0.0;
157          cellData[cellIndex].countForceReceived = 0;
158
159          cellIndex++;
160     }
161   }
162 //  CmiPrintf("BgNodeStart [%d,%d,%d] cells mapped\n", x, y, z);
163
164   /* declare and set node private data */
165   LittleMDData *lmdData = new LittleMDData;
166   lmdData->systemPotEnergy      = 0.0;
167   lmdData->systemKinEnergy      = 0.0;
168   lmdData->numberOfCellsDone    = 0;
169   lmdData->systemStepsCompleted = 0;
170   lmdData->nreported = 0;
171
172   UserData *ud  = new UserData;
173   ud->lmdData   = lmdData;
174   ud->cellData  = cellData;
175   ud->cellCount = numCellMapped;
176   ud->cellPairData = NULL;
177   ud->spData    = spData;
178   ud->step      = 0;
179
180   BgSetNodeData((char*)ud);
181
182   //CmiPrintf("BgNodeStart [%d,%d,%d] creating micro-task\n", x, y, z);
183   /* trigger computation at each node */
184   StepMsg *msg = new StepMsg(0);
185   BgSendLocalPacket(ANYTHREAD, sendCoordID, LARGE_WORK, sizeof(StepMsg), (char*)msg);
186
187 //  CmiPrintf("BgNodeStart Done [%d,%d,%d]\n", x, y, z);
188   if (x==0 && y==0 && z==0) startTime = BgGetTime();
189 }