--- trunk/src/brains/BlockSnapshotManager.cpp 2005/02/15 19:36:07 351 +++ branches/development/src/brains/BlockSnapshotManager.cpp 2011/09/14 21:15:17 1629 @@ -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,53 +28,87 @@ * 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/physmem.h" +//#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), activeRefCount_(blockCapacity_, 0) { +namespace OpenMD { + BlockSnapshotManager::BlockSnapshotManager(SimInfo* info, + const std::string& filename, + int storageLayout, + long long int memSize, + int blockCapacity) + : SnapshotManager(storageLayout), info_(info), memSize_(memSize), + blockCapacity_(blockCapacity), activeBlocks_(blockCapacity_, -1), + activeRefCount_(blockCapacity_, 0) { - nAtoms_ = info->getNGlobalAtoms(); - nRigidBodies_ = info->getNGlobalRigidBodies(); + nAtoms_ = info->getNGlobalAtoms(); + nRigidBodies_ = info->getNGlobalRigidBodies(); + nCutoffGroups_ = info->getNCutoffGroups(); - double avalPhysMem = physmem_available(); + // eliminate suspect calls to figure out free memory: + // RealType physMem = physmem_total(); + // RealType rssMem = residentMem(); + // RealType avaliablePhysMem = physMem - rssMem; - int bytesPerStuntDouble = DataStorage::getBytesPerStuntDouble(storageLayout); + int bytesPerStuntDouble = DataStorage::getBytesPerStuntDouble(storageLayout); + int bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble; - int bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble; + // total number of frames that can fit in memory + //RealType frameCapacity = avaliablePhysMem / bytesPerFrame; + RealType frameCapacity = memSize_ / bytesPerFrame; - int frameCapacity = int (avalPhysMem / 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; + } - nSnapshotPerBlock_ = frameCapacity /blockCapacity_ ; + 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_; - reader_ = new DumpReader(info, filename); - nframes_ = reader_->getNFrames(); + snapshots_.insert(snapshots_.begin(), nframes_, static_cast(NULL)); - int nblocks = nframes_ / nSnapshotPerBlock_; - if (nframes_ % nSnapshotPerBlock_ != 0) { - ++nblocks; - } + std::cout << "-----------------------------------------------------"<(NULL)); - -} - -BlockSnapshotManager::~BlockSnapshotManager() { + BlockSnapshotManager::~BlockSnapshotManager() { currentSnapshot_ = NULL; previousSnapshot_ = NULL; @@ -91,13 +116,18 @@ BlockSnapshotManager::~BlockSnapshotManager() { std::vector::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); @@ -105,58 +135,58 @@ int BlockSnapshotManager::getNActiveBlocks() { #else return std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::bind2nd(std::not_equal_to(), -1)); #endif -} + } -bool BlockSnapshotManager::loadBlock(int block) { + bool BlockSnapshotManager::loadBlock(int block) { std::vector::iterator i = findActiveBlock(block); bool loadSuccess; if (i != activeBlocks_.end()) { - //if block is already in memory, just increast the reference count - ++activeRefCount_[i - activeBlocks_.begin()]; - loadSuccess = true; + //if block is already in memory, just increast the reference count + ++activeRefCount_[i - activeBlocks_.begin()]; + loadSuccess = true; } else if (getNActiveBlocks() < blockCapacity_){ - //if number of active blocks is less than the block capacity, just load it - internalLoad(block); - loadSuccess = true; + //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); + //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; + //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; 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; - } + --activeRefCount_[i - activeBlocks_.begin()]; + if (activeRefCount_[i - activeBlocks_.begin()] < 0) { + //in case, unloadBlock called multiple times + activeRefCount_[i - activeBlocks_.begin()] = 0; + } - unloadSuccess = true; + unloadSuccess = true; } else { - unloadSuccess = false; + unloadSuccess = false; } return unloadSuccess; -} + } -void BlockSnapshotManager::internalLoad(int block) { + void BlockSnapshotManager::internalLoad(int block) { for (int i = blocks_[block].first; i < blocks_[block].second; ++i) { - snapshots_[i] = loadFrame(i); + snapshots_[i] = loadFrame(i); } std::vector::iterator j; @@ -164,49 +194,56 @@ void BlockSnapshotManager::internalLoad(int block) { assert(j != activeBlocks_.end()); *j = block; ++activeRefCount_[j - activeBlocks_.begin()]; -} + } -void BlockSnapshotManager::internalUnload(int block) { + void BlockSnapshotManager::internalUnload(int block) { for (int i = blocks_[block].first; i < blocks_[block].second; ++i) { - delete snapshots_[i]; - snapshots_[i] = NULL; + 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); -} + 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; -} + 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 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* snapshot = new Snapshot(nAtoms_, nRigidBodies_, getStorageLayout()); + Snapshot* BlockSnapshotManager::loadFrame(int frame){ + Snapshot* snapshot = new Snapshot(nAtoms_, nRigidBodies_, nCutoffGroups_, getStorageLayout()); snapshot->setID(frame); /** @todo fixed me */ 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); + } + }