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

Comparing trunk/OOPSE-2.0/src/brains/BlockSnapshotManager.cpp (file contents):
Revision 2031 by tim, Tue Feb 15 17:11:35 2005 UTC vs.
Revision 2042 by tim, Thu Feb 17 15:18:36 2005 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"
# Line 48 | Line 49 | BlockSnapshotManager::BlockSnapshotManager(SimInfo* in
49   namespace oopse {
50   BlockSnapshotManager::BlockSnapshotManager(SimInfo* info, const std::string& filename,
51      int storageLayout, int blockCapacity)
52 <    : SnapshotManager(storageLayout), info_(info), blockCapacity_(blockCapacity), activeBlocks_(blockCapacity_, -1) {
52 >    : SnapshotManager(storageLayout), info_(info), blockCapacity_(blockCapacity),
53 >      activeBlocks_(blockCapacity_, -1), activeRefCount_(blockCapacity_, 0) {
54  
55      nAtoms_ = info->getNGlobalAtoms();
56      nRigidBodies_ = info->getNGlobalRigidBodies();
57  
58 <    double avalPhysMem = physmem_available();
58 >    double physMem = physmem_total();
59 >    double rssMem = residentMem();
60 >    double avaliablePhysMem = physMem - rssMem;
61      
62      int bytesPerStuntDouble = DataStorage::getBytesPerStuntDouble(storageLayout);
63  
64      int bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble;
65  
66 <    int frameCapacity = int (avalPhysMem / bytesPerFrame);
66 >    int frameCapacity = int (avaliablePhysMem / bytesPerFrame);
67      
68      nSnapshotPerBlock_ = frameCapacity /blockCapacity_ ;
65 –
69      reader_ = new DumpReader(info, filename);
70      nframes_ = reader_->getNFrames();
71  
# Line 78 | Line 81 | BlockSnapshotManager::BlockSnapshotManager(SimInfo* in
81      blocks_.back().second = nframes_;
82  
83      snapshots_.insert(snapshots_.begin(), nframes_, static_cast<Snapshot*>(NULL));  
84 +
85 +    std::cout << "physmem = " << int(physMem) << "\trssMem =  "<< int(rssMem) << "\t availablePhysMem = " << int(avaliablePhysMem) <<std::endl;
86 +    std::cout << "nSnapshotPerBlock = " << nSnapshotPerBlock_ << "\t total block = " << nblocks << std::endl;
87      
88   }
89  
# Line 106 | Line 112 | bool BlockSnapshotManager::isBlockActive(int block) {
112   #endif
113   }
114  
109 – bool BlockSnapshotManager::isBlockActive(int block) {
110 –    return std::find(activeBlocks_.begin(), activeBlocks_.end(), block) != activeBlocks_.end() ? true : false;
111 – }
115  
116 +
117   bool BlockSnapshotManager::loadBlock(int block) {
118 +    std::vector<int>::iterator i = findActiveBlock(block);
119      bool loadSuccess;
120 <    if (isBlockActive(block)) {
120 >    if (i != activeBlocks_.end()) {
121 >        //if block is already in memory, just increast the reference count
122 >        ++activeRefCount_[i - activeBlocks_.begin()];
123          loadSuccess = true;
124      } else if (getNActiveBlocks() < blockCapacity_){
125 <
126 <        for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
120 <            snapshots_[i] = loadFrame(i);
121 <        }
122 <        
123 <        std::vector<int>::iterator j;
124 <        j = std::find(activeBlocks_.begin(), activeBlocks_.end(), -1);
125 <        assert(j != activeBlocks_.end());
126 <        *j = block;    
125 >        //if number of active blocks is less than the block capacity, just load it
126 >        internalLoad(block);
127          loadSuccess = true;
128 <    }else {
128 >    } else if (hasZeroRefBlock() > 0) {
129 >        //if already reach the block capacity, need to unload a block with 0 reference
130 >        int zeroRefBlock = getFirstZeroRefBlock();
131 >        assert(zeroRefBlock != -1);
132 >        internalUnload(zeroRefBlock);
133 >        internalLoad(block);
134 >    } else {
135 >        //reach the capacity and all blocks in memory are not zero reference
136          loadSuccess = false;
137      }
138 <
138 >    
139      return loadSuccess;
140   }
141  
142   bool BlockSnapshotManager::unloadBlock(int block) {
143      bool unloadSuccess;
144 <    if (!isBlockActive(block)){
145 <        unloadSuccess = false;
146 <    } else {
147 <        for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
148 <            delete snapshots_[i];
149 <            snapshots_[i] = NULL;
144 >    std::vector<int>::iterator i = findActiveBlock(block);
145 >    
146 >    if (i != activeBlocks_.end()){
147 >        --activeRefCount_[i - activeBlocks_.begin()];
148 >        if (activeRefCount_[i - activeBlocks_.begin()] < 0) {
149 >            //in case, unloadBlock called multiple times
150 >            activeRefCount_[i - activeBlocks_.begin()]  = 0;
151          }
152 <        std::vector<int>::iterator j;
145 <        j = std::find(activeBlocks_.begin(), activeBlocks_.end(), block);
146 <        assert(j != activeBlocks_.end());
147 <        *j = -1;
152 >        
153          unloadSuccess = true;
154 +    } else {
155 +        unloadSuccess = false;
156      }
157  
158      return unloadSuccess;
159   }
160  
161 + void BlockSnapshotManager::internalLoad(int block) {
162 +        
163 +    for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
164 +        snapshots_[i] = loadFrame(i);
165 +    }
166 +    
167 +    std::vector<int>::iterator j;
168 +    j = std::find(activeBlocks_.begin(), activeBlocks_.end(), -1);
169 +    assert(j != activeBlocks_.end());
170 +    *j = block;    
171 +    ++activeRefCount_[j - activeBlocks_.begin()];
172 + }
173 +
174 + void BlockSnapshotManager::internalUnload(int block) {
175 +    for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
176 +        delete snapshots_[i];
177 +        snapshots_[i] = NULL;
178 +    }
179 +    std::vector<int>::iterator j;
180 +    j = std::find(activeBlocks_.begin(), activeBlocks_.end(), block);
181 +    assert(j != activeBlocks_.end());
182 +    *j = -1;
183 + }
184 +
185 + bool BlockSnapshotManager::hasZeroRefBlock(){
186 +    return std::find(activeRefCount_.begin(), activeRefCount_.end(), 0) != activeRefCount_.end() ?  true : false;
187 + }
188 +
189 + int BlockSnapshotManager::getFirstZeroRefBlock(){
190 +     std::vector<int>::iterator i = std::find(activeRefCount_.begin(), activeRefCount_.end(), 0);
191 +     return i != activeRefCount_.end() ? activeBlocks_[i - activeRefCount_.begin()] : -1;
192 + }
193 +
194   std::vector<int> BlockSnapshotManager::getActiveBlocks() {
195      std::vector<int> result;
196      oopse::copy_if(activeBlocks_.begin(), activeBlocks_.end(), std::back_inserter(result),

Diff Legend

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