ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/brains/BlockSnapshotManager.cpp
(Generate patch)

Comparing trunk/src/brains/BlockSnapshotManager.cpp (file contents):
Revision 351 by tim, Tue Feb 15 19:36:07 2005 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC

# Line 6 | Line 6
6   * redistribute this software in source and binary code form, provided
7   * that the following conditions are met:
8   *
9 < * 1. Acknowledgement of the program authors must be made in any
10 < *    publication of scientific results based in part on use of the
11 < *    program.  An acceptable form of acknowledgement is citation of
12 < *    the article in which the program was described (Matthew
13 < *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 < *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 < *    Parallel Simulation Engine for Molecular Dynamics,"
16 < *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 < *
18 < * 2. Redistributions of source code must retain the above copyright
9 > * 1. Redistributions of source code must retain the above copyright
10   *    notice, this list of conditions and the following disclaimer.
11   *
12 < * 3. Redistributions in binary form must reproduce the above copyright
12 > * 2. Redistributions in binary form must reproduce the above copyright
13   *    notice, this list of conditions and the following disclaimer in the
14   *    documentation and/or other materials provided with the
15   *    distribution.
# Line 37 | Line 28
28   * arising out of the use of or inability to use software, even if the
29   * University of Notre Dame has been advised of the possibility of
30   * such damages.
31 + *
32 + * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 + * research, please cite the appropriate papers when you publish your
34 + * work.  Good starting points are:
35 + *                                                                      
36 + * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37 + * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 + * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 + * [4]  Vardeman & Gezelter, in progress (2009).                        
40   */
41   #include <algorithm>
42   #include "brains/BlockSnapshotManager.hpp"
43 + #include "utils/residentMem.h"
44   #include "utils/physmem.h"
45   #include "utils/Algorithm.hpp"
46   #include "brains/SimInfo.hpp"
47   #include "io/DumpReader.hpp"
48  
49 < namespace oopse {
50 < BlockSnapshotManager::BlockSnapshotManager(SimInfo* info, const std::string& filename,
51 <    int storageLayout, int blockCapacity)
49 > namespace OpenMD {
50 >  BlockSnapshotManager::BlockSnapshotManager(SimInfo* info, const std::string& filename,
51 >                                             int storageLayout, int blockCapacity)
52      : SnapshotManager(storageLayout), info_(info), blockCapacity_(blockCapacity),
53        activeBlocks_(blockCapacity_, -1), activeRefCount_(blockCapacity_, 0) {
54  
55 <    nAtoms_ = info->getNGlobalAtoms();
56 <    nRigidBodies_ = info->getNGlobalRigidBodies();
55 >      nAtoms_ = info->getNGlobalAtoms();
56 >      nRigidBodies_ = info->getNGlobalRigidBodies();
57  
58 <    double avalPhysMem = physmem_available();
59 <    
60 <    int bytesPerStuntDouble = DataStorage::getBytesPerStuntDouble(storageLayout);
58 >      RealType physMem = physmem_total();
59 >      RealType rssMem = residentMem();
60 >      RealType avaliablePhysMem = physMem - rssMem;
61  
61 –    int bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble;
62 –
63 –    int frameCapacity = int (avalPhysMem / bytesPerFrame);
62      
63 <    nSnapshotPerBlock_ = frameCapacity /blockCapacity_ ;
63 >      int bytesPerStuntDouble = DataStorage::getBytesPerStuntDouble(storageLayout);
64  
65 <    reader_ = new DumpReader(info, filename);
68 <    nframes_ = reader_->getNFrames();
65 >      int bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble;
66  
67 <    int nblocks = nframes_ / nSnapshotPerBlock_;
68 <    if (nframes_ % nSnapshotPerBlock_ != 0) {
67 >      // total number of frames that can fit in memory
68 >      RealType frameCapacity = avaliablePhysMem / bytesPerFrame;
69 >
70 >      // number of frames in each block given the need to hold multiple blocks
71 >      // in memory at the same time:
72 >      nSnapshotPerBlock_ = int(frameCapacity) / blockCapacity_;
73 >      reader_ = new DumpReader(info, filename);
74 >      nframes_ = reader_->getNFrames();
75 >      int nblocks = nframes_ / nSnapshotPerBlock_;
76 >      if (nframes_ % int(nSnapshotPerBlock_) != 0) {
77          ++nblocks;
78 <    }  
78 >      }  
79      
80 <    for (int i = 0; i < nblocks; ++i) {
80 >      for (int i = 0; i < nblocks; ++i) {
81          blocks_.push_back(SnapshotBlock(i*nSnapshotPerBlock_, (i+1)*nSnapshotPerBlock_));    
82 <    }
83 <    //the last block may not have nSnapshotPerBlock frames, we need to consider this special situation
84 <    blocks_.back().second = nframes_;
82 >      }
83 >      //the last block may not have nSnapshotPerBlock frames, we need to consider this special situation
84 >      blocks_.back().second = nframes_;
85  
86 <    snapshots_.insert(snapshots_.begin(), nframes_, static_cast<Snapshot*>(NULL));  
86 >      snapshots_.insert(snapshots_.begin(), nframes_, static_cast<Snapshot*>(NULL));  
87 >
88 >      std::cout << "-----------------------------------------------------"<<std::endl;
89 >      std::cout << "BlockSnapshotManager memory report:" << std::endl;
90 >      std::cout << "\n";
91 >      std::cout << "  Physical Memory available:\t" << (unsigned long)physMem <<  " bytes" <<std::endl;
92 >      std::cout << "     Resident Memory in use:\t" << (unsigned long)rssMem << " bytes" <<std::endl;
93 >      std::cout << "Memory available for OpenMD:\t" << (unsigned long)avaliablePhysMem << " bytes" <<std::endl;
94 >      std::cout << "      Bytes per StuntDouble:\t" << (unsigned long)bytesPerStuntDouble <<std::endl;
95 >      std::cout << "            Bytes per Frame:\t" << (unsigned long)bytesPerFrame <<std::endl;
96 >      std::cout << "             Frame Capacity:\t" << (unsigned long)frameCapacity <<std::endl;
97 >      std::cout << "       Frames in trajectory:\t" << (unsigned long)nframes_ <<std::endl;
98 >      std::cout << "        Snapshots per Block:\t" << (unsigned long)nSnapshotPerBlock_ <<std::endl;
99 >      std::cout << "     Total number of Blocks:\t" << (unsigned long)nblocks << std::endl;
100 >      std::cout << "-----------------------------------------------------"<<std::endl;
101      
102 < }
102 >    }
103  
104  
105 < BlockSnapshotManager::~BlockSnapshotManager() {
105 >  BlockSnapshotManager::~BlockSnapshotManager() {
106      currentSnapshot_ = NULL;
107      previousSnapshot_ = NULL;
108      
# Line 91 | Line 110 | BlockSnapshotManager::~BlockSnapshotManager() {
110  
111      std::vector<int>::iterator i;
112      for (i = activeBlocks_.begin(); i != activeBlocks_.end(); ++i) {
113 <        if (*i != -1) {
114 <            unloadBlock(*i);
115 <        }
113 >      if (*i != -1) {
114 >        unloadBlock(*i);
115 >      }
116      }
117 < }
117 >  }
118  
119 < int BlockSnapshotManager::getNActiveBlocks() {
119 >   Snapshot* BlockSnapshotManager::getSnapshot(int id) {
120 >    currentSnapshot_ = snapshots_[id];
121 >    return snapshots_[id];
122 >  }
123 >
124 >  int BlockSnapshotManager::getNActiveBlocks() {
125   #ifdef __RWSTD  
126      int count = 0;
127      std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::bind2nd(std::not_equal_to<int>(), -1), count);
# Line 105 | Line 129 | int BlockSnapshotManager::getNActiveBlocks() {
129   #else
130      return std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::bind2nd(std::not_equal_to<int>(), -1));
131   #endif
132 < }
132 >  }
133  
134  
135  
136 < bool BlockSnapshotManager::loadBlock(int block) {
136 >  bool BlockSnapshotManager::loadBlock(int block) {
137      std::vector<int>::iterator i = findActiveBlock(block);
138      bool loadSuccess;
139      if (i != activeBlocks_.end()) {
140 <        //if block is already in memory, just increast the reference count
141 <        ++activeRefCount_[i - activeBlocks_.begin()];
142 <        loadSuccess = true;
140 >      //if block is already in memory, just increast the reference count
141 >      ++activeRefCount_[i - activeBlocks_.begin()];
142 >      loadSuccess = true;
143      } else if (getNActiveBlocks() < blockCapacity_){
144 <        //if number of active blocks is less than the block capacity, just load it
145 <        internalLoad(block);
146 <        loadSuccess = true;
144 >      //if number of active blocks is less than the block capacity, just load it
145 >      internalLoad(block);
146 >      loadSuccess = true;
147      } else if (hasZeroRefBlock() > 0) {
148 <        //if already reach the block capacity, need to unload a block with 0 reference
149 <        int zeroRefBlock = getFirstZeroRefBlock();
150 <        assert(zeroRefBlock != -1);
151 <        internalUnload(zeroRefBlock);
152 <        internalLoad(block);
148 >      //if already reach the block capacity, need to unload a block with 0 reference
149 >      int zeroRefBlock = getFirstZeroRefBlock();
150 >      assert(zeroRefBlock != -1);
151 >      internalUnload(zeroRefBlock);
152 >      internalLoad(block);
153      } else {
154 <        //reach the capacity and all blocks in memory are not zero reference
155 <        loadSuccess = false;
154 >      //reach the capacity and all blocks in memory are not zero reference
155 >      loadSuccess = false;
156      }
157      
158      return loadSuccess;
159 < }
159 >  }
160  
161 < bool BlockSnapshotManager::unloadBlock(int block) {
161 >  bool BlockSnapshotManager::unloadBlock(int block) {
162      bool unloadSuccess;
163      std::vector<int>::iterator i = findActiveBlock(block);
164      
165      if (i != activeBlocks_.end()){
166 <        --activeRefCount_[i - activeBlocks_.begin()];
167 <        if (activeRefCount_[i - activeBlocks_.begin()] < 0) {
168 <            //in case, unloadBlock called multiple times
169 <            activeRefCount_[i - activeBlocks_.begin()]  = 0;
170 <        }
166 >      --activeRefCount_[i - activeBlocks_.begin()];
167 >      if (activeRefCount_[i - activeBlocks_.begin()] < 0) {
168 >        //in case, unloadBlock called multiple times
169 >        activeRefCount_[i - activeBlocks_.begin()]  = 0;
170 >      }
171          
172 <        unloadSuccess = true;
172 >      unloadSuccess = true;
173      } else {
174 <        unloadSuccess = false;
174 >      unloadSuccess = false;
175      }
176  
177      return unloadSuccess;
178 < }
178 >  }
179  
180 < void BlockSnapshotManager::internalLoad(int block) {
180 >  void BlockSnapshotManager::internalLoad(int block) {
181          
182      for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
183 <        snapshots_[i] = loadFrame(i);
183 >      snapshots_[i] = loadFrame(i);
184      }
185      
186      std::vector<int>::iterator j;
# Line 164 | Line 188 | void BlockSnapshotManager::internalLoad(int block) {
188      assert(j != activeBlocks_.end());
189      *j = block;    
190      ++activeRefCount_[j - activeBlocks_.begin()];
191 < }
191 >  }
192  
193 < void BlockSnapshotManager::internalUnload(int block) {
193 >  void BlockSnapshotManager::internalUnload(int block) {
194      for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
195 <        delete snapshots_[i];
196 <        snapshots_[i] = NULL;
195 >      delete snapshots_[i];
196 >      snapshots_[i] = NULL;
197      }
198      std::vector<int>::iterator j;
199      j = std::find(activeBlocks_.begin(), activeBlocks_.end(), block);
200      assert(j != activeBlocks_.end());
201      *j = -1;
202 < }
202 >  }
203  
204 < bool BlockSnapshotManager::hasZeroRefBlock(){
205 <    return std::find(activeRefCount_.begin(), activeRefCount_.end(), 0);
206 < }
204 >  bool BlockSnapshotManager::hasZeroRefBlock(){
205 >    return std::find(activeRefCount_.begin(), activeRefCount_.end(), 0) != activeRefCount_.end() ?  true : false;
206 >  }
207  
208 < int BlockSnapshotManager::getFirstZeroRefBlock(){
209 <     std::vector<int>::iterator i = std::find(activeRefCount_.begin(), activeRefCount_.end(), 0);
210 <     return i != activeRefCount_.end() ? activeBlocks_[i - activeRefCount_.begin()] : -1;
211 < }
208 >  int BlockSnapshotManager::getFirstZeroRefBlock(){
209 >    std::vector<int>::iterator i = std::find(activeRefCount_.begin(), activeRefCount_.end(), 0);
210 >    return i != activeRefCount_.end() ? activeBlocks_[i - activeRefCount_.begin()] : -1;
211 >  }
212  
213 < std::vector<int> BlockSnapshotManager::getActiveBlocks() {
213 >  std::vector<int> BlockSnapshotManager::getActiveBlocks() {
214      std::vector<int> result;
215 <    oopse::copy_if(activeBlocks_.begin(), activeBlocks_.end(), std::back_inserter(result),
216 <        std::bind2nd(std::not_equal_to<int>(), -1));
215 >    OpenMD::copy_if(activeBlocks_.begin(), activeBlocks_.end(), std::back_inserter(result),
216 >                   std::bind2nd(std::not_equal_to<int>(), -1));
217      return result;    
218 < }
218 >  }
219  
220 < Snapshot* BlockSnapshotManager::loadFrame(int frame){
220 >  Snapshot* BlockSnapshotManager::loadFrame(int frame){
221      Snapshot* snapshot = new Snapshot(nAtoms_, nRigidBodies_, getStorageLayout());
222      snapshot->setID(frame);
223      
# Line 201 | Line 225 | Snapshot* BlockSnapshotManager::loadFrame(int frame){
225      Snapshot* oldSnapshot = currentSnapshot_;
226      currentSnapshot_ = snapshot;  
227      reader_->readFrame(frame);
228 <    currentSnapshot_ = oldSnapshot;
228 >
229 >    // What was this for?  It doesn't make sense!
230 >    //currentSnapshot_ = oldSnapshot;
231 >
232      return snapshot;
233 < }
233 >  }
234  
235 < int BlockSnapshotManager::getNFrames() {
235 >  int BlockSnapshotManager::getNFrames() {
236      return reader_->getNFrames();
237 < }
237 >  }
238  
239 +  void BlockSnapshotManager::needCOMprops(bool ncp) {
240 +    reader_->setNeedCOMprops(ncp);
241 +  }
242 +
243   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines