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 1596 by gezelter, Mon Jul 25 17:30:53 2011 UTC vs.
Revision 1966 by gezelter, Fri Jan 24 14:17:42 2014 UTC

# Line 35 | Line 35
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).                        
38 > * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).          
39 > * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40 > * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41   */
42   #include <algorithm>
43   #include "brains/BlockSnapshotManager.hpp"
44 < // #include "utils/residentMem.h"
45 < // #include "utils/physmem.h"
44 > //#include "utils/residentMem.h"
45 > //#include "utils/physmem.h"
46   #include "utils/Algorithm.hpp"
47   #include "brains/SimInfo.hpp"
48   #include "io/DumpReader.hpp"
# Line 49 | Line 50 | namespace OpenMD {
50   namespace OpenMD {
51    BlockSnapshotManager::BlockSnapshotManager(SimInfo* info,
52                                               const std::string& filename,
53 <                                             int storageLayout,
54 <                                             long long int memSize,
53 >                                             int storageLayout,
54 >                                             long long int memSize,
55                                               int blockCapacity)
56 <    : SnapshotManager(storageLayout), info_(info), memSize_(memSize),
56 >    : SnapshotManager(storageLayout), info_(info), memSize_(memSize),
57        blockCapacity_(blockCapacity), activeBlocks_(blockCapacity_, -1),
58        activeRefCount_(blockCapacity_, 0) {
59  
60        nAtoms_ = info->getNGlobalAtoms();
61        nRigidBodies_ = info->getNGlobalRigidBodies();
62 +      nCutoffGroups_ = info->getNCutoffGroups();
63  
64        // eliminate suspect calls to figure out free memory:
65        // RealType physMem = physmem_total();
66        // RealType rssMem = residentMem();
67        // RealType avaliablePhysMem = physMem - rssMem;
68 <
68 >    
69        int bytesPerStuntDouble = DataStorage::getBytesPerStuntDouble(storageLayout);
70 +      int bytesPerCutoffGroup = DataStorage::getBytesPerStuntDouble(DataStorage::dslPosition);
71  
72 <      int bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble;
72 >      int bytesPerFrameData = Snapshot::getFrameDataSize();
73 >      int bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble
74 >        + nCutoffGroups_ * bytesPerCutoffGroup
75 >        + bytesPerFrameData;
76  
77        // total number of frames that can fit in memory
72 –      
78        //RealType frameCapacity = avaliablePhysMem / bytesPerFrame;
79 <      RealType frameCapacity = memSize_ / bytesPerFrame;
79 >      RealType frameCapacity = (RealType) memSize_ / (RealType) bytesPerFrame;
80  
81        // number of frames in each block given the need to hold multiple blocks
82        // in memory at the same time:
83        nSnapshotPerBlock_ = int(frameCapacity) / blockCapacity_;
84 +      if (nSnapshotPerBlock_ <= 0) {
85 +       std::cerr << "not enough memory to hold two configs!" << std::endl;
86 +      }
87        reader_ = new DumpReader(info, filename);
88        nframes_ = reader_->getNFrames();
89        int nblocks = nframes_ / nSnapshotPerBlock_;
# Line 91 | Line 99 | namespace OpenMD {
99  
100        snapshots_.insert(snapshots_.begin(), nframes_, static_cast<Snapshot*>(NULL));  
101  
102 <      std::cout << "-----------------------------------------------------"<<std::endl;
102 >      std::cout << "-----------------------------------------------------"
103 >                << std::endl;
104        std::cout << "BlockSnapshotManager memory report:" << std::endl;
105        std::cout << "\n";
106        // std::cout << "  Physical Memory available:\t" << (unsigned long)physMem <<  " bytes" <<std::endl;
107        //std::cout << "     Resident Memory in use:\t" << (unsigned long)rssMem << " bytes" <<std::endl;
108        //std::cout << "Memory available for OpenMD:\t" << (unsigned long)avaliablePhysMem << " bytes" <<std::endl;
109 <      std::cout << "Memory requested for OpenMD:\t" << (unsigned long)memSize_ << " bytes" <<std::endl;
110 <      std::cout << "      Bytes per StuntDouble:\t" << (unsigned long)bytesPerStuntDouble <<std::endl;
111 <      std::cout << "            Bytes per Frame:\t" << (unsigned long)bytesPerFrame <<std::endl;
112 <      std::cout << "             Frame Capacity:\t" << (unsigned long)frameCapacity <<std::endl;
113 <      std::cout << "       Frames in trajectory:\t" << (unsigned long)nframes_ <<std::endl;
114 <      std::cout << "        Snapshots per Block:\t" << (unsigned long)nSnapshotPerBlock_ <<std::endl;
115 <      std::cout << "     Total number of Blocks:\t" << (unsigned long)nblocks << std::endl;
116 <      std::cout << "-----------------------------------------------------"<<std::endl;
109 >      std::cout << "Memory requested for OpenMD:\t"
110 >                << (unsigned long)memSize_ << " bytes" << std::endl;
111 >      std::cout << "        Bytes per FrameData:\t"
112 >                << (unsigned long)bytesPerFrameData << std::endl;
113 >      std::cout << "      Bytes per StuntDouble:\t"
114 >                << (unsigned long)bytesPerStuntDouble << std::endl;
115 >      std::cout << "     Bytes per Cutoff Group:\t"
116 >                << (unsigned long)bytesPerCutoffGroup << std::endl;
117 >      std::cout << "            Bytes per Frame:\t"
118 >                << (unsigned long)bytesPerFrame << std::endl;
119 >      std::cout << "             Frame Capacity:\t"
120 >                << (unsigned long)frameCapacity << std::endl;
121 >      std::cout << "       Frames in trajectory:\t"
122 >                << (unsigned long)nframes_ << std::endl;
123 >      std::cout << "        Snapshots per Block:\t"
124 >                << (unsigned long)nSnapshotPerBlock_ << std::endl;
125 >      std::cout << "     Total number of Blocks:\t"
126 >                << (unsigned long)nblocks << std::endl;
127 >      std::cout << "-----------------------------------------------------"
128 >                << std::endl;
129      
130      }
131  
# Line 151 | Line 172 | namespace OpenMD {
172        //if number of active blocks is less than the block capacity, just load it
173        internalLoad(block);
174        loadSuccess = true;
175 <    } else if (hasZeroRefBlock() > 0) {
175 >    } else if ( hasZeroRefBlock() ) {
176        //if already reach the block capacity, need to unload a block with 0 reference
177        int zeroRefBlock = getFirstZeroRefBlock();
178        assert(zeroRefBlock != -1);
# Line 175 | Line 196 | namespace OpenMD {
196          //in case, unloadBlock called multiple times
197          activeRefCount_[i - activeBlocks_.begin()]  = 0;
198        }
199 +
200 +      if (activeRefCount_[i-activeBlocks_.begin()] == 0) {
201 +        internalUnload(block);
202 +      }
203          
204        unloadSuccess = true;
205      } else {
# Line 198 | Line 223 | namespace OpenMD {
223    }
224  
225    void BlockSnapshotManager::internalUnload(int block) {
226 +    std::cerr << "called internal unload for block "<< block << "\n";
227      for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
228        delete snapshots_[i];
229        snapshots_[i] = NULL;
# Line 225 | Line 251 | namespace OpenMD {
251    }
252  
253    Snapshot* BlockSnapshotManager::loadFrame(int frame){
254 <    Snapshot* snapshot = new Snapshot(nAtoms_, nRigidBodies_, getStorageLayout());
254 >    Snapshot* snapshot = new Snapshot(nAtoms_, nRigidBodies_, nCutoffGroups_,
255 >                                      getStorageLayout());
256      snapshot->setID(frame);
257 +    snapshot->clearDerivedProperties();
258      
231 –    /** @todo fixed me */
232 –    Snapshot* oldSnapshot = currentSnapshot_;
259      currentSnapshot_ = snapshot;  
260      reader_->readFrame(frame);
261  
236 –    // What was this for?  It doesn't make sense!
237 –    //currentSnapshot_ = oldSnapshot;
238 –
262      return snapshot;
263    }
264  

Diff Legend

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