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

Comparing trunk/src/brains/BlockSnapshotManager.cpp (file contents):
Revision 322 by tim, Sun Feb 13 08:05:33 2005 UTC vs.
Revision 1215 by xsun, Wed Jan 23 21:22:37 2008 UTC

# Line 40 | Line 40
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)
52 <    : SnapshotManager(storageLayout), info_(info),
53 <      blockCapacity_(blockCapacity), activeBlocks(blockCapacity_, -1) {
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();
58 >      RealType physMem = physmem_total();
59 >      RealType rssMem = residentMem();
60 >      RealType avaliablePhysMem = physMem - rssMem;
61 >
62      
63 <    int bytesPerStuntDouble = DataStorage::getBytesPerStuntDouble(storageLayout);
63 >      int bytesPerStuntDouble = DataStorage::getBytesPerStuntDouble(storageLayout);
64  
65 <    int bytesPerFrame = nStuntDoubles * bytesPerStuntDouble;
65 >      int bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble;
66  
67 <    int frameCapacity = int (avalPhysMem / bytesPerFrame);
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 >      }  
79      
80 <    nSnapshotPerBlock_ = frameCapacity /blockCapacity_ ;
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_;
85  
86 <    reader_ = new DumpReader(info, filename);
67 <    nframes_ = reader->getNFrames();
86 >      snapshots_.insert(snapshots_.begin(), nframes_, static_cast<Snapshot*>(NULL));  
87  
88 <    int nblocks = nframes / nSnapshotPerBlock_;
89 <    if (nframes % nSnapshotPerBlock != 0) {
90 <        ++nblocks;
91 <    }  
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 OOPSE:\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      
74 –    for (int i = 0; i < nblocks; ++i) {
75 –        blocks_.push_back(SnapshotBlock(i, (i+1)*nSnapshotPerBlock_);    
102      }
77 –    //the last block may not have nSnapshotPerBlock frames, we need to consider this special situation
78 –    blocks.back.second = nframes;
103  
80 –    snapshots_.insert(snapshot_.begin(), nframes, NULL);  
81 –    
82 – }
104  
105 <
85 < BlockSnapshotMananger::~BlockSnapshotMananger() {
105 >  BlockSnapshotManager::~BlockSnapshotManager() {
106      currentSnapshot_ = NULL;
107      previousSnapshot_ = NULL;
108      
109      delete reader_;
90 –    std::for_each(activeBlocks_.begin(), activeBlocks_.end(), unloadBlock);
91 – }
110  
111 < int BlockSnapshotManager::getNActiveBlocks() {
112 <    return std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::not);
113 < }
111 >    std::vector<int>::iterator i;
112 >    for (i = activeBlocks_.begin(); i != activeBlocks_.end(); ++i) {
113 >      if (*i != -1) {
114 >        unloadBlock(*i);
115 >      }
116 >    }
117 >  }
118  
97 – bool BlockSnapshotManager::isBlockActive(int block) {
98 –    return std::find(activeBlocks_.begin(), activeBlocks_.end(), block) != activeBlocks_.end() ? true : false;
99 – }
119  
120 < bool BlockSnapshotManager::loadBlock(int block) {
120 >  // virtual Snapshot* BlockSnapshotManager::getSnapshot(int id) {
121 >  //  currentSnapshot_ = snapshots[id];
122 >  //  return snapshots_[id];
123 >  //}
124 >
125 >  int BlockSnapshotManager::getNActiveBlocks() {
126 > #ifdef __RWSTD  
127 >    int count = 0;
128 >    std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::bind2nd(std::not_equal_to<int>(), -1), count);
129 >    return count;
130 > #else
131 >    return std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::bind2nd(std::not_equal_to<int>(), -1));
132 > #endif
133 >  }
134 >
135 >
136 >
137 >  bool BlockSnapshotManager::loadBlock(int block) {
138 >    std::vector<int>::iterator i = findActiveBlock(block);
139      bool loadSuccess;
140 <    if (isBlockActive(block)) {
141 <        loadSuccess = true;
140 >    if (i != activeBlocks_.end()) {
141 >      //if block is already in memory, just increast the reference count
142 >      ++activeRefCount_[i - activeBlocks_.begin()];
143 >      loadSuccess = true;
144      } else if (getNActiveBlocks() < blockCapacity_){
145 <
146 <        for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
147 <            snapshots_[i] = loadFrame(i);
148 <        }
149 <        
150 <        std::vector<int>::iterator j;
151 <        j = std::find(activeBlocks_.begin(), activeBlocks_.end(), -1);
152 <        assert(j != activeBlocks_.end());
153 <        *j = block;    
154 <        loadSuccess = true;
155 <    }else {
156 <        loadSuccess = false;
145 >      //if number of active blocks is less than the block capacity, just load it
146 >      internalLoad(block);
147 >      loadSuccess = true;
148 >    } else if (hasZeroRefBlock() > 0) {
149 >      //if already reach the block capacity, need to unload a block with 0 reference
150 >      int zeroRefBlock = getFirstZeroRefBlock();
151 >      assert(zeroRefBlock != -1);
152 >      internalUnload(zeroRefBlock);
153 >      internalLoad(block);
154 >    } else {
155 >      //reach the capacity and all blocks in memory are not zero reference
156 >      loadSuccess = false;
157      }
158 <
158 >    
159      return loadSuccess;
160 < }
160 >  }
161  
162 < bool BlockSnapshotManager::unloadBlock(int block) {
162 >  bool BlockSnapshotManager::unloadBlock(int block) {
163      bool unloadSuccess;
164 <    if (!isBlockActive(block)){
165 <        unloadSuccess = false;
164 >    std::vector<int>::iterator i = findActiveBlock(block);
165 >    
166 >    if (i != activeBlocks_.end()){
167 >      --activeRefCount_[i - activeBlocks_.begin()];
168 >      if (activeRefCount_[i - activeBlocks_.begin()] < 0) {
169 >        //in case, unloadBlock called multiple times
170 >        activeRefCount_[i - activeBlocks_.begin()]  = 0;
171 >      }
172 >        
173 >      unloadSuccess = true;
174      } else {
175 <        for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
129 <            delete snapshots_[i];
130 <            snapshots_[i] = NULL;
131 <        }
132 <        std::vector<int>::iterator j;
133 <        j = std::find(activeBlocks_.begin(), activeBlocks_.end(), block);
134 <        assert(j != activeBlocks_.end());
135 <        *j = -1;
175 >      unloadSuccess = false;
176      }
137 – }
177  
178 < std::vector<int> BlockSnapshotManager::getActiveBlocks() {
178 >    return unloadSuccess;
179 >  }
180 >
181 >  void BlockSnapshotManager::internalLoad(int block) {
182 >        
183 >    for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
184 >      snapshots_[i] = loadFrame(i);
185 >    }
186 >    
187 >    std::vector<int>::iterator j;
188 >    j = std::find(activeBlocks_.begin(), activeBlocks_.end(), -1);
189 >    assert(j != activeBlocks_.end());
190 >    *j = block;    
191 >    ++activeRefCount_[j - activeBlocks_.begin()];
192 >  }
193 >
194 >  void BlockSnapshotManager::internalUnload(int block) {
195 >    for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
196 >      delete snapshots_[i];
197 >      snapshots_[i] = NULL;
198 >    }
199 >    std::vector<int>::iterator j;
200 >    j = std::find(activeBlocks_.begin(), activeBlocks_.end(), block);
201 >    assert(j != activeBlocks_.end());
202 >    *j = -1;
203 >  }
204 >
205 >  bool BlockSnapshotManager::hasZeroRefBlock(){
206 >    return std::find(activeRefCount_.begin(), activeRefCount_.end(), 0) != activeRefCount_.end() ?  true : false;
207 >  }
208 >
209 >  int BlockSnapshotManager::getFirstZeroRefBlock(){
210 >    std::vector<int>::iterator i = std::find(activeRefCount_.begin(), activeRefCount_.end(), 0);
211 >    return i != activeRefCount_.end() ? activeBlocks_[i - activeRefCount_.begin()] : -1;
212 >  }
213 >
214 >  std::vector<int> BlockSnapshotManager::getActiveBlocks() {
215      std::vector<int> result;
216 <    std::copy_if(activeBlocks_.begin(), activeBlocks_.end());
217 < }
216 >    oopse::copy_if(activeBlocks_.begin(), activeBlocks_.end(), std::back_inserter(result),
217 >                   std::bind2nd(std::not_equal_to<int>(), -1));
218 >    return result;    
219 >  }
220  
221 < Snapshot* BlockSnapshotManager::loadFrame(int frame){
221 >  Snapshot* BlockSnapshotManager::loadFrame(int frame){
222      Snapshot* snapshot = new Snapshot(nAtoms_, nRigidBodies_, getStorageLayout());
223      snapshot->setID(frame);
224 <    setCurrentSnapshot(snapshot);   /** @todo fixed me */
224 >    
225 >    /** @todo fixed me */
226 >    Snapshot* oldSnapshot = currentSnapshot_;
227 >    currentSnapshot_ = snapshot;  
228      reader_->readFrame(frame);
229 +
230 +    // What was this for?  It doesn't make sense!
231 +    //currentSnapshot_ = oldSnapshot;
232 +
233      return snapshot;
234 < }
234 >  }
235  
236 < int BlockSnapshotManager::getNFrames() {
236 >  int BlockSnapshotManager::getNFrames() {
237      return reader_->getNFrames();
238 < }
238 >  }
239  
240 +  void BlockSnapshotManager::needCOMprops(bool ncp) {
241 +    reader_->setNeedCOMprops(ncp);
242 +  }
243 +
244   }

Diff Legend

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