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 2006 by tim, Sun Feb 13 08:05:33 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"
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) {
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 = nStuntDoubles * bytesPerStuntDouble;
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();
70 >    nframes_ = reader_->getNFrames();
71  
72 <    int nblocks = nframes / nSnapshotPerBlock_;
73 <    if (nframes % nSnapshotPerBlock != 0) {
72 >    int nblocks = nframes_ / nSnapshotPerBlock_;
73 >    if (nframes_ % nSnapshotPerBlock_ != 0) {
74          ++nblocks;
75      }  
76      
77      for (int i = 0; i < nblocks; ++i) {
78 <        blocks_.push_back(SnapshotBlock(i, (i+1)*nSnapshotPerBlock_);    
78 >        blocks_.push_back(SnapshotBlock(i*nSnapshotPerBlock_, (i+1)*nSnapshotPerBlock_));    
79      }
80      //the last block may not have nSnapshotPerBlock frames, we need to consider this special situation
81 <    blocks.back.second = nframes;
81 >    blocks_.back().second = nframes_;
82  
83 <    snapshots_.insert(snapshot_.begin(), nframes, NULL);  
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  
90  
91 < BlockSnapshotMananger::~BlockSnapshotMananger() {
91 > BlockSnapshotManager::~BlockSnapshotManager() {
92      currentSnapshot_ = NULL;
93      previousSnapshot_ = NULL;
94      
95      delete reader_;
96 <    std::for_each(activeBlocks_.begin(), activeBlocks_.end(), unloadBlock);
96 >
97 >    std::vector<int>::iterator i;
98 >    for (i = activeBlocks_.begin(); i != activeBlocks_.end(); ++i) {
99 >        if (*i != -1) {
100 >            unloadBlock(*i);
101 >        }
102 >    }
103   }
104  
105   int BlockSnapshotManager::getNActiveBlocks() {
106 <    return std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::not);
106 > #ifdef __RWSTD  
107 >    int count = 0;
108 >    std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::bind2nd(std::not_equal_to<int>(), -1), count);
109 >    return count;
110 > #else
111 >    return std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::bind2nd(std::not_equal_to<int>(), -1));
112 > #endif
113   }
114  
97 – bool BlockSnapshotManager::isBlockActive(int block) {
98 –    return std::find(activeBlocks_.begin(), activeBlocks_.end(), block) != activeBlocks_.end() ? true : false;
99 – }
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) {
108 <            snapshots_[i] = loadFrame(i);
109 <        }
110 <        
111 <        std::vector<int>::iterator j;
112 <        j = std::find(activeBlocks_.begin(), activeBlocks_.end(), -1);
113 <        assert(j != activeBlocks_.end());
114 <        *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;
153 <        j = std::find(activeBlocks_.begin(), activeBlocks_.end(), block);
154 <        assert(j != activeBlocks_.end());
155 <        *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 <    std::copy_if(activeBlocks_.begin(), activeBlocks_.end());
196 >    oopse::copy_if(activeBlocks_.begin(), activeBlocks_.end(), std::back_inserter(result),
197 >        std::bind2nd(std::not_equal_to<int>(), -1));
198 >    return result;    
199   }
200  
201   Snapshot* BlockSnapshotManager::loadFrame(int frame){
202      Snapshot* snapshot = new Snapshot(nAtoms_, nRigidBodies_, getStorageLayout());
203      snapshot->setID(frame);
204 <    setCurrentSnapshot(snapshot);   /** @todo fixed me */
204 >    
205 >    /** @todo fixed me */
206 >    Snapshot* oldSnapshot = currentSnapshot_;
207 >    currentSnapshot_ = snapshot;  
208      reader_->readFrame(frame);
209 +    currentSnapshot_ = oldSnapshot;
210      return snapshot;
211   }
212  

Diff Legend

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