# | Line 1 | Line 1 | |
---|---|---|
1 | #ifdef IS_MPI | |
2 | < | |
2 | > | #include <iostream> |
3 | #include <cstdlib> | |
4 | #include <cstring> | |
5 | #include <cmath> | |
# | Line 25 | Line 25 | mpiSimulation::mpiSimulation(SimInfo* the_entryPlug) | |
25 | ||
26 | MolToProcMap = new int[entryPlug->n_mol]; | |
27 | MolComponentType = new int[entryPlug->n_mol]; | |
28 | – | |
28 | AtomToProcMap = new int[entryPlug->n_atoms]; | |
29 | ||
30 | mpiSim = this; | |
# | Line 134 | Line 133 | int* mpiSimulation::divideLabor( void ){ | |
133 | // How many atoms does this processor have? | |
134 | ||
135 | old_atoms = AtomsPerProc[which_proc]; | |
136 | + | add_atoms = compStamps[MolComponentType[i]]->getNAtoms(); |
137 | + | new_atoms = old_atoms + add_atoms; |
138 | ||
139 | // If the processor already had too many atoms, just skip this | |
140 | // processor and try again. | |
141 | ||
141 | – | if (old_atoms >= nTarget) continue; |
142 | – | |
143 | – | add_atoms = compStamps[MolComponentType[i]]->getNAtoms(); |
144 | – | new_atoms = old_atoms + add_atoms; |
145 | – | |
146 | – | // If we can add this molecule to this processor without sending |
147 | – | // it above nTarget, then go ahead and do it: |
148 | – | |
149 | – | if (new_atoms <= nTarget) { |
150 | – | MolToProcMap[i] = which_proc; |
151 | – | AtomsPerProc[which_proc] += add_atoms; |
152 | – | for (j = 0 ; j < add_atoms; j++ ) { |
153 | – | atomIndex++; |
154 | – | AtomToProcMap[atomIndex] = which_proc; |
155 | – | } |
156 | – | done = 1; |
157 | – | continue; |
158 | – | } |
159 | – | |
142 | // If we've been through this loop too many times, we need | |
143 | // to just give up and assign the molecule to this processor | |
144 | // and be done with it. | |
# | Line 173 | Line 155 | int* mpiSimulation::divideLabor( void ){ | |
155 | MolToProcMap[i] = which_proc; | |
156 | AtomsPerProc[which_proc] += add_atoms; | |
157 | for (j = 0 ; j < add_atoms; j++ ) { | |
158 | < | atomIndex++; |
159 | < | AtomToProcMap[atomIndex] = which_proc; |
158 | > | AtomToProcMap[atomIndex] = which_proc; |
159 | > | atomIndex++; |
160 | } | |
161 | done = 1; | |
162 | continue; | |
163 | } | |
164 | ||
165 | + | if (old_atoms >= nTarget) continue; |
166 | + | |
167 | + | // If we can add this molecule to this processor without sending |
168 | + | // it above nTarget, then go ahead and do it: |
169 | + | |
170 | + | if (new_atoms <= nTarget) { |
171 | + | MolToProcMap[i] = which_proc; |
172 | + | AtomsPerProc[which_proc] += add_atoms; |
173 | + | for (j = 0 ; j < add_atoms; j++ ) { |
174 | + | AtomToProcMap[atomIndex] = which_proc; |
175 | + | atomIndex++; |
176 | + | } |
177 | + | done = 1; |
178 | + | continue; |
179 | + | } |
180 | + | |
181 | + | |
182 | // The only situation left is where old_atoms < nTarget, but | |
183 | // new_atoms > nTarget. We want to accept this with some | |
184 | // probability that dies off the farther we are from nTarget | |
# | Line 195 | Line 194 | int* mpiSimulation::divideLabor( void ){ | |
194 | MolToProcMap[i] = which_proc; | |
195 | AtomsPerProc[which_proc] += add_atoms; | |
196 | for (j = 0 ; j < add_atoms; j++ ) { | |
197 | < | atomIndex++; |
198 | < | AtomToProcMap[atomIndex] = which_proc; |
199 | < | } |
197 | > | AtomToProcMap[atomIndex] = which_proc; |
198 | > | atomIndex++; |
199 | > | } |
200 | done = 1; | |
201 | continue; | |
202 | } else { | |
# | Line 235 | Line 234 | int* mpiSimulation::divideLabor( void ){ | |
234 | ||
235 | MPI::COMM_WORLD.Bcast(AtomsPerProc, mpiPlug->numberProcessors, | |
236 | MPI_INT, 0); | |
237 | + | |
238 | + | |
239 | } | |
240 | ||
241 | ||
# | Line 254 | Line 255 | int* mpiSimulation::divideLabor( void ){ | |
255 | } | |
256 | } | |
257 | ||
258 | + | std::cerr << "proc = " << mpiPlug->myNode << " atoms = " << natoms_local << "\n"; |
259 | + | |
260 | MPI::COMM_WORLD.Allreduce(&nmol_local,&nmol_global,1,MPI_INT,MPI_SUM); | |
261 | MPI::COMM_WORLD.Allreduce(&natoms_local,&natoms_global,1,MPI_INT,MPI_SUM); | |
262 | ||
# | Line 286 | Line 289 | int* mpiSimulation::divideLabor( void ){ | |
289 | local_index = 0; | |
290 | for (i = 0; i < mpiPlug->nAtomsGlobal; i++) { | |
291 | if (AtomToProcMap[i] == mpiPlug->myNode) { | |
289 | – | local_index++; |
292 | globalIndex[local_index] = i; | |
293 | + | local_index++; |
294 | } | |
295 | } | |
296 | < | |
296 | > | |
297 | return globalIndex; | |
298 | } | |
299 |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |