Teuchos_Workspace.hpp

// @HEADER
// ***********************************************************************
// 
//                    Teuchos: Common Tools Package
//                 Copyright (2004) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef TEUCHOS_WORKSPACE_HPP
#define TEUCHOS_WORKSPACE_HPP

#include "Teuchos_RefCountPtr.hpp"
#include "Teuchos_TestForException.hpp"

namespace Teuchos {

class WorkspaceStore;
class RawWorkspace;


void set_default_workspace_store( const Teuchos::RefCountPtr<WorkspaceStore> &default_workspace_store );

Teuchos::RefCountPtr<WorkspaceStore> get_default_workspace_store();

void print_memory_usage_stats( const WorkspaceStore* workspace_store, std::ostream& out );

class RawWorkspace {
public:
  friend class WorkspaceStore;
  RawWorkspace(WorkspaceStore* workspace_store, size_t num_bytes);
  ~RawWorkspace();
  size_t num_bytes() const;
  char* workspace_ptr();
  const char* workspace_ptr() const;
private:
  WorkspaceStore   *workspace_store_;
  char             *workspace_begin_;
  char             *workspace_end_;
  bool             owns_memory_;  // If true then the pointed to memory was allocated with
                                  // new so we need to call delete on it when we are destroyed.
  // not defined and not to be called
  RawWorkspace();
  RawWorkspace(const RawWorkspace&);
  RawWorkspace& operator=(const RawWorkspace&);
  static void* operator new(size_t);
  static void operator delete(void*);
}; // end class RawWorkspace

template<class T>
class Workspace {
public:
  Workspace(WorkspaceStore* workspace_store, size_t num_elements, bool call_constructors = true);
  ~Workspace();
  size_t size() const;
  T& operator[](size_t i);
  const T& operator[](size_t i) const;
private:
  RawWorkspace  raw_workspace_;
  bool          call_constructors_;
  // not defined and not to be called
  Workspace();
  Workspace(const RawWorkspace&);
  Workspace& operator=(const RawWorkspace&);
  static void* operator new(size_t);
  static void operator delete(void*);
}; // end class Workspace

class WorkspaceStore {
public:
  friend class RawWorkspace;
  ~WorkspaceStore();
  size_t num_bytes_total() const;
  size_t num_bytes_remaining() const;
  int num_static_allocations() const;
  int num_dyn_allocations() const;
  size_t num_current_bytes_total();
  size_t num_max_bytes_needed() const;
protected:
  WorkspaceStore(size_t num_bytes);
  void protected_initialize(size_t num_bytes);
private:
  char    *workspace_begin_; // Points to the beginning of raw allocated workspace.
                             // If NULL then no workspace has been allocated yet.
  char    *workspace_end_;   // Points to one past the last byte of allocated workspace.
                             // workspace_end_ >= workspace_begin_
  char    *curr_ws_ptr_;     // Points to the first available byte of workspace.
                             // workspace_begin_ <= curr_ws_ptr_ <= workspace_end_
  int     num_static_allocations_; // Number of workspace allocation using already
                             // allocated memory.
  int     num_dyn_allocations_; // Number of workspace allocations using dynamic
                             // memory because the current workspace store was
                             // overridden
  size_t  num_current_bytes_total_; // Total bytes currently being used
  size_t  num_max_bytes_needed_; // Maximum number of bytes of storage needed
  // Not definted and not to be called
  WorkspaceStore(const WorkspaceStore&);
  WorkspaceStore& operator=(const WorkspaceStore&);
}; // end class WorkspaceStore

class WorkspaceStoreInitializeable
  : public WorkspaceStore
{
public:
  WorkspaceStoreInitializeable(size_t num_bytes = 0);
  void initialize(size_t num_bytes);
}; // end class WorkspaceStoreInitializeable


// /////////////////////////////////////
// Inline members for Workspace<T>

template<class T>
inline
Workspace<T>::Workspace(WorkspaceStore* workspace_store, size_t num_elements, bool call_constructors)
  : raw_workspace_(workspace_store,sizeof(T)*num_elements), call_constructors_(call_constructors)
{
  if(call_constructors_) {
    char* raw_ptr = raw_workspace_.workspace_ptr();
    for( size_t k = 0; k < num_elements; ++k, raw_ptr += sizeof(T) )
      ::new (raw_ptr) T(); // placement new
  }
}

template<class T>
inline
Workspace<T>::~Workspace()
{
  if(call_constructors_) {
    const size_t num_elements = this->size();
    char* raw_ptr = raw_workspace_.workspace_ptr();
    for( size_t k = 0; k < num_elements; ++k, raw_ptr += sizeof(T) )
      reinterpret_cast<T*>(raw_ptr)->~T();
  }
}

template<class T>
inline
size_t Workspace<T>::size() const
{
  return raw_workspace_.num_bytes() / sizeof(T);
}

template<class T>
inline
T& Workspace<T>::operator[](size_t i)
{
#ifdef _DEBUG
  TEST_FOR_EXCEPTION( !( i < this->size() ), std::invalid_argument, "Workspace<T>::operator[](i): Error!" );
#endif  
  return reinterpret_cast<T*>(raw_workspace_.workspace_ptr())[i];
}

template<class T>
inline
const T& Workspace<T>::operator[](size_t i) const
{
  return const_cast<Workspace<T>*>(this)->operator[](i);
}

#ifdef __PGI // Should not have to define this but pgCC is complaining!
template<class T>
inline
void* Workspace<T>::operator new(size_t)
{
  assert(0);
  return NULL;
}
#endif

// should not have to define this but the gcc-2.95.2 compiler is complaining!
template<class T>
inline
void Workspace<T>::operator delete(void*)
{
  assert(0);
}

// /////////////////////////////////////
// Inline members for WorkspaceStore

inline
size_t WorkspaceStore::num_bytes_total() const
{
  return workspace_end_ - workspace_begin_;
}

inline
size_t WorkspaceStore::num_bytes_remaining() const
{
  return workspace_end_ - curr_ws_ptr_;
}

inline
int WorkspaceStore::num_static_allocations() const
{
  return num_static_allocations_;
}

inline
int WorkspaceStore::num_dyn_allocations() const
{
  return num_dyn_allocations_;
}

inline
size_t WorkspaceStore::num_current_bytes_total()
{
  return num_current_bytes_total_;
}

inline
size_t WorkspaceStore::num_max_bytes_needed() const
{
  return num_max_bytes_needed_;
}

// /////////////////////////////////////////////////
// Inline members for WorkspaceStoreInitializeable

inline
WorkspaceStoreInitializeable::WorkspaceStoreInitializeable(size_t num_bytes)
  : WorkspaceStore(num_bytes)
{}

inline
void WorkspaceStoreInitializeable::initialize(size_t num_bytes)
{
  protected_initialize(num_bytes);
}

// /////////////////////////////////////
// Inline members for RawWorkspace

inline
size_t RawWorkspace::num_bytes() const
{
  return workspace_end_ - workspace_begin_;
}

inline
char* RawWorkspace::workspace_ptr()
{
  return workspace_begin_;
}

inline
const char* RawWorkspace::workspace_ptr() const
{
  return workspace_begin_;
}

// should not have to define this but the gcc-2.95.2 compiler is complaining!
inline
void RawWorkspace::operator delete(void*)
{
  assert(0);
}

} // end namespace Teuchos

#endif // TEUCHOS_WORKSPACE_HPP

---