Teuchos_Workspace.hpp

// @HEADER
// *****************************************************************************
//                    Teuchos: Common Tools Package
//
// Copyright 2004 NTESS and the Teuchos contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @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