--- trunk/src/brains/BlockSnapshotManager.cpp 2005/02/15 17:11:35 347 +++ branches/development/src/brains/BlockSnapshotManager.cpp 2010/07/09 23:08:25 1465 @@ -6,19 +6,10 @@ * redistribute this software in source and binary code form, provided * that the following conditions are met: * - * 1. Acknowledgement of the program authors must be made in any - * publication of scientific results based in part on use of the - * program. An acceptable form of acknowledgement is citation of - * the article in which the program was described (Matthew - * A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher - * J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented - * Parallel Simulation Engine for Molecular Dynamics," - * J. Comput. Chem. 26, pp. 252-271 (2005)) - * - * 2. Redistributions of source code must retain the above copyright + * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - * 3. Redistributions in binary form must reproduce the above copyright + * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the * distribution. @@ -37,52 +28,81 @@ * arising out of the use of or inability to use software, even if the * University of Notre Dame has been advised of the possibility of * such damages. + * + * SUPPORT OPEN SCIENCE! If you use OpenMD or its source code in your + * research, please cite the appropriate papers when you publish your + * work. Good starting points are: + * + * [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005). + * [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006). + * [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008). + * [4] Vardeman & Gezelter, in progress (2009). */ #include #include "brains/BlockSnapshotManager.hpp" +#include "utils/residentMem.h" #include "utils/physmem.h" #include "utils/Algorithm.hpp" #include "brains/SimInfo.hpp" #include "io/DumpReader.hpp" -namespace oopse { -BlockSnapshotManager::BlockSnapshotManager(SimInfo* info, const std::string& filename, - int storageLayout, int blockCapacity) - : SnapshotManager(storageLayout), info_(info), blockCapacity_(blockCapacity), activeBlocks_(blockCapacity_, -1) { +namespace OpenMD { + BlockSnapshotManager::BlockSnapshotManager(SimInfo* info, const std::string& filename, + int storageLayout, int blockCapacity) + : SnapshotManager(storageLayout), info_(info), blockCapacity_(blockCapacity), + activeBlocks_(blockCapacity_, -1), activeRefCount_(blockCapacity_, 0) { - nAtoms_ = info->getNGlobalAtoms(); - nRigidBodies_ = info->getNGlobalRigidBodies(); + nAtoms_ = info->getNGlobalAtoms(); + nRigidBodies_ = info->getNGlobalRigidBodies(); - double avalPhysMem = physmem_available(); - - int bytesPerStuntDouble = DataStorage::getBytesPerStuntDouble(storageLayout); + RealType physMem = physmem_total(); + RealType rssMem = residentMem(); + RealType avaliablePhysMem = physMem - rssMem; - int bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble; - - int frameCapacity = int (avalPhysMem / bytesPerFrame); - nSnapshotPerBlock_ = frameCapacity /blockCapacity_ ; + int bytesPerStuntDouble = DataStorage::getBytesPerStuntDouble(storageLayout); - reader_ = new DumpReader(info, filename); - nframes_ = reader_->getNFrames(); + int bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble; - int nblocks = nframes_ / nSnapshotPerBlock_; - if (nframes_ % nSnapshotPerBlock_ != 0) { + // total number of frames that can fit in memory + RealType frameCapacity = avaliablePhysMem / bytesPerFrame; + + // number of frames in each block given the need to hold multiple blocks + // in memory at the same time: + nSnapshotPerBlock_ = int(frameCapacity) / blockCapacity_; + reader_ = new DumpReader(info, filename); + nframes_ = reader_->getNFrames(); + int nblocks = nframes_ / nSnapshotPerBlock_; + if (nframes_ % int(nSnapshotPerBlock_) != 0) { ++nblocks; - } + } - for (int i = 0; i < nblocks; ++i) { + for (int i = 0; i < nblocks; ++i) { blocks_.push_back(SnapshotBlock(i*nSnapshotPerBlock_, (i+1)*nSnapshotPerBlock_)); - } - //the last block may not have nSnapshotPerBlock frames, we need to consider this special situation - blocks_.back().second = nframes_; + } + //the last block may not have nSnapshotPerBlock frames, we need to consider this special situation + blocks_.back().second = nframes_; - snapshots_.insert(snapshots_.begin(), nframes_, static_cast(NULL)); + snapshots_.insert(snapshots_.begin(), nframes_, static_cast(NULL)); + + std::cout << "-----------------------------------------------------"<::iterator i; for (i = activeBlocks_.begin(); i != activeBlocks_.end(); ++i) { - if (*i != -1) { - unloadBlock(*i); - } + if (*i != -1) { + unloadBlock(*i); + } } -} + } -int BlockSnapshotManager::getNActiveBlocks() { + Snapshot* BlockSnapshotManager::getSnapshot(int id) { + currentSnapshot_ = snapshots_[id]; + return snapshots_[id]; + } + + int BlockSnapshotManager::getNActiveBlocks() { #ifdef __RWSTD int count = 0; std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::bind2nd(std::not_equal_to(), -1), count); @@ -104,61 +129,95 @@ int BlockSnapshotManager::getNActiveBlocks() { #else return std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::bind2nd(std::not_equal_to(), -1)); #endif -} + } -bool BlockSnapshotManager::isBlockActive(int block) { - return std::find(activeBlocks_.begin(), activeBlocks_.end(), block) != activeBlocks_.end() ? true : false; -} -bool BlockSnapshotManager::loadBlock(int block) { + + bool BlockSnapshotManager::loadBlock(int block) { + std::vector::iterator i = findActiveBlock(block); bool loadSuccess; - if (isBlockActive(block)) { - loadSuccess = true; + if (i != activeBlocks_.end()) { + //if block is already in memory, just increast the reference count + ++activeRefCount_[i - activeBlocks_.begin()]; + loadSuccess = true; } else if (getNActiveBlocks() < blockCapacity_){ - - for (int i = blocks_[block].first; i < blocks_[block].second; ++i) { - snapshots_[i] = loadFrame(i); - } - - std::vector::iterator j; - j = std::find(activeBlocks_.begin(), activeBlocks_.end(), -1); - assert(j != activeBlocks_.end()); - *j = block; - loadSuccess = true; - }else { - loadSuccess = false; + //if number of active blocks is less than the block capacity, just load it + internalLoad(block); + loadSuccess = true; + } else if (hasZeroRefBlock() > 0) { + //if already reach the block capacity, need to unload a block with 0 reference + int zeroRefBlock = getFirstZeroRefBlock(); + assert(zeroRefBlock != -1); + internalUnload(zeroRefBlock); + internalLoad(block); + } else { + //reach the capacity and all blocks in memory are not zero reference + loadSuccess = false; } - + return loadSuccess; -} + } -bool BlockSnapshotManager::unloadBlock(int block) { + bool BlockSnapshotManager::unloadBlock(int block) { bool unloadSuccess; - if (!isBlockActive(block)){ - unloadSuccess = false; + std::vector::iterator i = findActiveBlock(block); + + if (i != activeBlocks_.end()){ + --activeRefCount_[i - activeBlocks_.begin()]; + if (activeRefCount_[i - activeBlocks_.begin()] < 0) { + //in case, unloadBlock called multiple times + activeRefCount_[i - activeBlocks_.begin()] = 0; + } + + unloadSuccess = true; } else { - for (int i = blocks_[block].first; i < blocks_[block].second; ++i) { - delete snapshots_[i]; - snapshots_[i] = NULL; - } - std::vector::iterator j; - j = std::find(activeBlocks_.begin(), activeBlocks_.end(), block); - assert(j != activeBlocks_.end()); - *j = -1; - unloadSuccess = true; + unloadSuccess = false; } return unloadSuccess; -} + } -std::vector BlockSnapshotManager::getActiveBlocks() { + void BlockSnapshotManager::internalLoad(int block) { + + for (int i = blocks_[block].first; i < blocks_[block].second; ++i) { + snapshots_[i] = loadFrame(i); + } + + std::vector::iterator j; + j = std::find(activeBlocks_.begin(), activeBlocks_.end(), -1); + assert(j != activeBlocks_.end()); + *j = block; + ++activeRefCount_[j - activeBlocks_.begin()]; + } + + void BlockSnapshotManager::internalUnload(int block) { + for (int i = blocks_[block].first; i < blocks_[block].second; ++i) { + delete snapshots_[i]; + snapshots_[i] = NULL; + } + std::vector::iterator j; + j = std::find(activeBlocks_.begin(), activeBlocks_.end(), block); + assert(j != activeBlocks_.end()); + *j = -1; + } + + bool BlockSnapshotManager::hasZeroRefBlock(){ + return std::find(activeRefCount_.begin(), activeRefCount_.end(), 0) != activeRefCount_.end() ? true : false; + } + + int BlockSnapshotManager::getFirstZeroRefBlock(){ + std::vector::iterator i = std::find(activeRefCount_.begin(), activeRefCount_.end(), 0); + return i != activeRefCount_.end() ? activeBlocks_[i - activeRefCount_.begin()] : -1; + } + + std::vector BlockSnapshotManager::getActiveBlocks() { std::vector result; - oopse::copy_if(activeBlocks_.begin(), activeBlocks_.end(), std::back_inserter(result), - std::bind2nd(std::not_equal_to(), -1)); + OpenMD::copy_if(activeBlocks_.begin(), activeBlocks_.end(), std::back_inserter(result), + std::bind2nd(std::not_equal_to(), -1)); return result; -} + } -Snapshot* BlockSnapshotManager::loadFrame(int frame){ + Snapshot* BlockSnapshotManager::loadFrame(int frame){ Snapshot* snapshot = new Snapshot(nAtoms_, nRigidBodies_, getStorageLayout()); snapshot->setID(frame); @@ -166,12 +225,19 @@ Snapshot* BlockSnapshotManager::loadFrame(int frame){ Snapshot* oldSnapshot = currentSnapshot_; currentSnapshot_ = snapshot; reader_->readFrame(frame); - currentSnapshot_ = oldSnapshot; + + // What was this for? It doesn't make sense! + //currentSnapshot_ = oldSnapshot; + return snapshot; -} + } -int BlockSnapshotManager::getNFrames() { + int BlockSnapshotManager::getNFrames() { return reader_->getNFrames(); -} + } + void BlockSnapshotManager::needCOMprops(bool ncp) { + reader_->setNeedCOMprops(ncp); + } + }