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