src/brains/BlockSnapshotManager.cpp

/*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 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.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * 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 <algorithm>
#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 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();

      // 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 bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble;

      // total number of frames that can fit in memory
      
      //RealType frameCapacity = avaliablePhysMem / bytesPerFrame;
      RealType frameCapacity = memSize_ / 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) {
        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_;

      snapshots_.insert(snapshots_.begin(), nframes_, static_cast<Snapshot*>(NULL));   

      std::cout << "-----------------------------------------------------"<<std::endl;
      std::cout << "BlockSnapshotManager memory report:" << std::endl;
      std::cout << "\n";
      // std::cout << "  Physical Memory available:\t" << (unsigned long)physMem <<  " bytes" <<std::endl;
      //std::cout << "     Resident Memory in use:\t" << (unsigned long)rssMem << " bytes" <<std::endl;
      //std::cout << "Memory available for OpenMD:\t" << (unsigned long)avaliablePhysMem << " bytes" <<std::endl;
      std::cout << "Memory requested for OpenMD:\t" << (unsigned long)memSize_ << " bytes" <<std::endl;
      std::cout << "      Bytes per StuntDouble:\t" << (unsigned long)bytesPerStuntDouble <<std::endl;
      std::cout << "            Bytes per Frame:\t" << (unsigned long)bytesPerFrame <<std::endl;
      std::cout << "             Frame Capacity:\t" << (unsigned long)frameCapacity <<std::endl;
      std::cout << "       Frames in trajectory:\t" << (unsigned long)nframes_ <<std::endl;
      std::cout << "        Snapshots per Block:\t" << (unsigned long)nSnapshotPerBlock_ <<std::endl;
      std::cout << "     Total number of Blocks:\t" << (unsigned long)nblocks << std::endl;
      std::cout << "-----------------------------------------------------"<<std::endl;
    
    }


  BlockSnapshotManager::~BlockSnapshotManager() {
    currentSnapshot_ = NULL;
    previousSnapshot_ = NULL;
    
    delete reader_;

    std::vector<int>::iterator i;
    for (i = activeBlocks_.begin(); i != activeBlocks_.end(); ++i) {
      if (*i != -1) {
        unloadBlock(*i);
      }
    }
  }

   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<int>(), -1), count);
    return count;
#else
    return std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::bind2nd(std::not_equal_to<int>(), -1));
#endif
  }


  bool BlockSnapshotManager::loadBlock(int block) {
    std::vector<int>::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;
    } else if (getNActiveBlocks() < blockCapacity_){
      //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 unloadSuccess;
    std::vector<int>::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 {
      unloadSuccess = false;
    }

    return unloadSuccess;
  }

  void BlockSnapshotManager::internalLoad(int block) {
        
    for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
      snapshots_[i] = loadFrame(i);
    }
    
    std::vector<int>::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<int>::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<int>::iterator i = std::find(activeRefCount_.begin(), activeRefCount_.end(), 0);
    return i != activeRefCount_.end() ? activeBlocks_[i - activeRefCount_.begin()] : -1;
  }

  std::vector<int> BlockSnapshotManager::getActiveBlocks() {
    std::vector<int> result;
    OpenMD::copy_if(activeBlocks_.begin(), activeBlocks_.end(), std::back_inserter(result), 
                   std::bind2nd(std::not_equal_to<int>(), -1));
    return result;    
  }

  Snapshot* BlockSnapshotManager::loadFrame(int frame){
    Snapshot* snapshot = new Snapshot(nAtoms_, nRigidBodies_, getStorageLayout());
    snapshot->setID(frame);
    
    /** @todo fixed me */
    Snapshot* oldSnapshot = currentSnapshot_;
    currentSnapshot_ = snapshot;   
    reader_->readFrame(frame);

    // What was this for?  It doesn't make sense!
    //currentSnapshot_ = oldSnapshot;

    return snapshot;
  }

  int BlockSnapshotManager::getNFrames() {
    return reader_->getNFrames();
  }

  void BlockSnapshotManager::needCOMprops(bool ncp) {
    reader_->setNeedCOMprops(ncp);
  }

}
Revision:	1596
Committed:	Mon Jul 25 17:30:53 2011 UTC (13 years, 9 months ago) by gezelter
File size:	9816 byte(s)
Log Message:	Updated the BlockSnapshotManager to use a specified memory footprint in constructor and not to rely on physmem and residentMem to figure out free memory. DynamicProps is the only program that uses the BlockSnapshotManager, so substantial changes were needed there as well.
#	Content
1	/*
2	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3	*
4	* The University of Notre Dame grants you ("Licensee") a
5	* non-exclusive, royalty free, license to use, modify and
6	* redistribute this software in source and binary code form, provided
7	* that the following conditions are met:
8	*
9	* 1. Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.
11	*
12	* 2. Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the
15	* distribution.
16	*
17	* This software is provided "AS IS," without a warranty of any
18	* kind. All express or implied conditions, representations and
19	* warranties, including any implied warranty of merchantability,
20	* fitness for a particular purpose or non-infringement, are hereby
21	* excluded. The University of Notre Dame and its licensors shall not
22	* be liable for any damages suffered by licensee as a result of
23	* using, modifying or distributing the software or its
24	* derivatives. In no event will the University of Notre Dame or its
25	* licensors be liable for any lost revenue, profit or data, or for
26	* direct, indirect, special, consequential, incidental or punitive
27	* damages, however caused and regardless of the theory of liability,
28	* arising out of the use of or inability to use software, even if the
29	* University of Notre Dame has been advised of the possibility of
30	* such damages.
31	*
32	* SUPPORT OPEN SCIENCE! If you use OpenMD or its source code in your
33	* research, please cite the appropriate papers when you publish your
34	* work. Good starting points are:
35	*
36	* [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37	* [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38	* [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).
39	* [4] Vardeman & Gezelter, in progress (2009).
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 OpenMD {
50	BlockSnapshotManager::BlockSnapshotManager(SimInfo* info,
51	const std::string& filename,
52	int storageLayout,
53	long long int memSize,
54	int blockCapacity)
55	: SnapshotManager(storageLayout), info_(info), memSize_(memSize),
56	blockCapacity_(blockCapacity), activeBlocks_(blockCapacity_, -1),
57	activeRefCount_(blockCapacity_, 0) {
58
59	nAtoms_ = info->getNGlobalAtoms();
60	nRigidBodies_ = info->getNGlobalRigidBodies();
61
62	// eliminate suspect calls to figure out free memory:
63	// RealType physMem = physmem_total();
64	// RealType rssMem = residentMem();
65	// RealType avaliablePhysMem = physMem - rssMem;
66
67	int bytesPerStuntDouble = DataStorage::getBytesPerStuntDouble(storageLayout);
68
69	int bytesPerFrame = (nRigidBodies_ + nAtoms_) * bytesPerStuntDouble;
70
71	// total number of frames that can fit in memory
72
73	//RealType frameCapacity = avaliablePhysMem / bytesPerFrame;
74	RealType frameCapacity = memSize_ / bytesPerFrame;
75
76	// number of frames in each block given the need to hold multiple blocks
77	// in memory at the same time:
78	nSnapshotPerBlock_ = int(frameCapacity) / blockCapacity_;
79	reader_ = new DumpReader(info, filename);
80	nframes_ = reader_->getNFrames();
81	int nblocks = nframes_ / nSnapshotPerBlock_;
82	if (nframes_ % int(nSnapshotPerBlock_) != 0) {
83	++nblocks;
84	}
85
86	for (int i = 0; i < nblocks; ++i) {
87	blocks_.push_back(SnapshotBlock(inSnapshotPerBlock_, (i+1)nSnapshotPerBlock_));
88	}
89	//the last block may not have nSnapshotPerBlock frames, we need to consider this special situation
90	blocks_.back().second = nframes_;
91
92	snapshots_.insert(snapshots_.begin(), nframes_, static_cast<Snapshot*>(NULL));
93
94	std::cout << "-----------------------------------------------------"<<std::endl;
95	std::cout << "BlockSnapshotManager memory report:" << std::endl;
96	std::cout << "\n";
97	// std::cout << " Physical Memory available:\t" << (unsigned long)physMem << " bytes" <<std::endl;
98	//std::cout << " Resident Memory in use:\t" << (unsigned long)rssMem << " bytes" <<std::endl;
99	//std::cout << "Memory available for OpenMD:\t" << (unsigned long)avaliablePhysMem << " bytes" <<std::endl;
100	std::cout << "Memory requested for OpenMD:\t" << (unsigned long)memSize_ << " bytes" <<std::endl;
101	std::cout << " Bytes per StuntDouble:\t" << (unsigned long)bytesPerStuntDouble <<std::endl;
102	std::cout << " Bytes per Frame:\t" << (unsigned long)bytesPerFrame <<std::endl;
103	std::cout << " Frame Capacity:\t" << (unsigned long)frameCapacity <<std::endl;
104	std::cout << " Frames in trajectory:\t" << (unsigned long)nframes_ <<std::endl;
105	std::cout << " Snapshots per Block:\t" << (unsigned long)nSnapshotPerBlock_ <<std::endl;
106	std::cout << " Total number of Blocks:\t" << (unsigned long)nblocks << std::endl;
107	std::cout << "-----------------------------------------------------"<<std::endl;
108
109	}
110
111
112	BlockSnapshotManager::~BlockSnapshotManager() {
113	currentSnapshot_ = NULL;
114	previousSnapshot_ = NULL;
115
116	delete reader_;
117
118	std::vector<int>::iterator i;
119	for (i = activeBlocks_.begin(); i != activeBlocks_.end(); ++i) {
120	if (*i != -1) {
121	unloadBlock(*i);
122	}
123	}
124	}
125
126	Snapshot* BlockSnapshotManager::getSnapshot(int id) {
127	currentSnapshot_ = snapshots_[id];
128	return snapshots_[id];
129	}
130
131	int BlockSnapshotManager::getNActiveBlocks() {
132	#ifdef __RWSTD
133	int count = 0;
134	std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::bind2nd(std::not_equal_to<int>(), -1), count);
135	return count;
136	#else
137	return std::count_if(activeBlocks_.begin(), activeBlocks_.end(), std::bind2nd(std::not_equal_to<int>(), -1));
138	#endif
139	}
140
141
142
143	bool BlockSnapshotManager::loadBlock(int block) {
144	std::vector<int>::iterator i = findActiveBlock(block);
145	bool loadSuccess;
146	if (i != activeBlocks_.end()) {
147	//if block is already in memory, just increast the reference count
148	++activeRefCount_[i - activeBlocks_.begin()];
149	loadSuccess = true;
150	} else if (getNActiveBlocks() < blockCapacity_){
151	//if number of active blocks is less than the block capacity, just load it
152	internalLoad(block);
153	loadSuccess = true;
154	} else if (hasZeroRefBlock() > 0) {
155	//if already reach the block capacity, need to unload a block with 0 reference
156	int zeroRefBlock = getFirstZeroRefBlock();
157	assert(zeroRefBlock != -1);
158	internalUnload(zeroRefBlock);
159	internalLoad(block);
160	} else {
161	//reach the capacity and all blocks in memory are not zero reference
162	loadSuccess = false;
163	}
164
165	return loadSuccess;
166	}
167
168	bool BlockSnapshotManager::unloadBlock(int block) {
169	bool unloadSuccess;
170	std::vector<int>::iterator i = findActiveBlock(block);
171
172	if (i != activeBlocks_.end()){
173	--activeRefCount_[i - activeBlocks_.begin()];
174	if (activeRefCount_[i - activeBlocks_.begin()] < 0) {
175	//in case, unloadBlock called multiple times
176	activeRefCount_[i - activeBlocks_.begin()] = 0;
177	}
178
179	unloadSuccess = true;
180	} else {
181	unloadSuccess = false;
182	}
183
184	return unloadSuccess;
185	}
186
187	void BlockSnapshotManager::internalLoad(int block) {
188
189	for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
190	snapshots_[i] = loadFrame(i);
191	}
192
193	std::vector<int>::iterator j;
194	j = std::find(activeBlocks_.begin(), activeBlocks_.end(), -1);
195	assert(j != activeBlocks_.end());
196	*j = block;
197	++activeRefCount_[j - activeBlocks_.begin()];
198	}
199
200	void BlockSnapshotManager::internalUnload(int block) {
201	for (int i = blocks_[block].first; i < blocks_[block].second; ++i) {
202	delete snapshots_[i];
203	snapshots_[i] = NULL;
204	}
205	std::vector<int>::iterator j;
206	j = std::find(activeBlocks_.begin(), activeBlocks_.end(), block);
207	assert(j != activeBlocks_.end());
208	*j = -1;
209	}
210
211	bool BlockSnapshotManager::hasZeroRefBlock(){
212	return std::find(activeRefCount_.begin(), activeRefCount_.end(), 0) != activeRefCount_.end() ? true : false;
213	}
214
215	int BlockSnapshotManager::getFirstZeroRefBlock(){
216	std::vector<int>::iterator i = std::find(activeRefCount_.begin(), activeRefCount_.end(), 0);
217	return i != activeRefCount_.end() ? activeBlocks_[i - activeRefCount_.begin()] : -1;
218	}
219
220	std::vector<int> BlockSnapshotManager::getActiveBlocks() {
221	std::vector<int> result;
222	OpenMD::copy_if(activeBlocks_.begin(), activeBlocks_.end(), std::back_inserter(result),
223	std::bind2nd(std::not_equal_to<int>(), -1));
224	return result;
225	}
226
227	Snapshot* BlockSnapshotManager::loadFrame(int frame){
228	Snapshot* snapshot = new Snapshot(nAtoms_, nRigidBodies_, getStorageLayout());
229	snapshot->setID(frame);
230
231	/** @todo fixed me */
232	Snapshot* oldSnapshot = currentSnapshot_;
233	currentSnapshot_ = snapshot;
234	reader_->readFrame(frame);
235
236	// What was this for? It doesn't make sense!
237	//currentSnapshot_ = oldSnapshot;
238
239	return snapshot;
240	}
241
242	int BlockSnapshotManager::getNFrames() {
243	return reader_->getNFrames();
244	}
245
246	void BlockSnapshotManager::needCOMprops(bool ncp) {
247	reader_->setNeedCOMprops(ncp);
248	}
249
250	}