Teuchos_Workspace.hpp

Go to the documentation of this file.

// @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.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted 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.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
//
// ***********************************************************************
// @HEADER
 
#ifndef TEUCHOS_WORKSPACE_HPP
#define TEUCHOS_WORKSPACE_HPP
 
#include "Teuchos_RCP.hpp"
#include "Teuchos_ArrayView.hpp"
#include "Teuchos_Assert.hpp"
 
namespace Teuchos {
 
class WorkspaceStore;
class RawWorkspace;
 
 
TEUCHOSCORE_LIB_DLL_EXPORT void set_default_workspace_store( const Teuchos::RCP<WorkspaceStore> &default_workspace_store );
 
TEUCHOSCORE_LIB_DLL_EXPORT Teuchos::RCP<WorkspaceStore> get_default_workspace_store();
 
TEUCHOSCORE_LIB_DLL_EXPORT void print_memory_usage_stats( const WorkspaceStore* workspace_store, std::ostream& out );
 
class TEUCHOSCORE_LIB_DLL_EXPORT 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* getRawPtr();
  const T* getRawPtr() const;
  T& operator[](size_t i);
  const T& operator[](size_t i) const;
  ArrayView<T> operator()();
  ArrayView<const T> operator()() const;
  operator ArrayView<T>();
  operator ArrayView<const T>() 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 TEUCHOSCORE_LIB_DLL_EXPORT 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>::getRawPtr()
{
  return ( size() ? &(*this)[0] : 0 );
}
 
template<class T>
inline
const T* Workspace<T>::getRawPtr() const
{
  return ( size() ? &(*this)[0] : 0 );
}
 
template<class T>
inline
T& Workspace<T>::operator[](size_t i)
{
#ifdef TEUCHOS_DEBUG
  TEUCHOS_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);
}
 
template<class T>
inline
ArrayView<T> Workspace<T>::operator()()
{
  if (size()==0)
    return Teuchos::null;
  return arrayView<T>( &(*this)[0], size() );
}
 
template<class T>
inline
ArrayView<const T>
Workspace<T>::operator()() const
{
  if (size()==0)
    return Teuchos::null;
  return arrayView<const T>( &(*this)[0], size() );
}
 
template<class T>
inline
Workspace<T>::operator ArrayView<T>()
{
  return (*this)();
}
 
template<class T>
inline
Workspace<T>::operator ArrayView<const T>() const
{
  return (*this)();
}
 
#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