dash::Shared< ElementType > Class Template Reference

Shared access to a value in global memory across a team. More...

#include <Shared.h>

Public Types
typedef size_t	size_type
typedef size_t	difference_type
typedef GlobRef< element_t >	reference
typedef GlobRef< const element_t >	const_reference
typedef reference::value_type	value_type

Public Member Functions
	Shared (team_unit_t owner=team_unit_t(0), Team &team=dash::Team::All())
	Constructor, allocates shared value at single unit in specified team. More...
	Shared (const value_type &val, team_unit_t owner=team_unit_t(0), Team &team=dash::Team::All())
	Constructor, allocates shared value at single unit in specified team. More...
	~Shared ()=default
	Destructor, frees shared memory. More...
	Shared (const self_t &other)=delete
	Copy-constructor: DELETED. More...
	Shared (self_t &&other) noexcept
	Move-constructor. More...
self_t &	operator= (const self_t &other)=delete
	Assignment operator: DELETED. More...
self_t &	operator= (self_t &&other) DASH_NOEXCEPT
	Move-assignment operator. More...
bool	init (value_type val=value_type{})
	Collective allocation of a shared variable with an initial value. More...
void	set (const value_type &val)
	Set the value of the shared element. More...
reference	get ()
	Get a reference on the shared value. More...
const_reference	get () const
	Get a const reference on the shared value. More...
constexpr value_type const *	local () const noexcept
	Native pointer to the starting address of the local memory of the unit that initialized this dash::Shared instance. More...
value_type *	local () noexcept
	Native pointer to the starting address of the local memory of the unit that initialized this dash::Shared instance. More...
dash::team_unit_t	owner () const noexcept
	The unit owning the memory in the global address space. More...
dash::Team &	team () const noexcept
	The dash::Team that created this shared object. More...
void	flush ()
	Flush global memory of shared value. More...
void	barrier ()
	Flush global memory of shared value and synchronize its associated units. More...
dart_gptr_t	dart_gptr () const noexcept
	Get underlying DART global pointer of the shared variable. More...

Friends
template<typename T_ >
void	swap (Shared< T_ > &a, Shared< T_ > &b)

Detailed Description

template<typename ElementType>
class dash::Shared< ElementType >

Shared access to a value in global memory across a team.

Template Parameters

ElementType

The type of the shared value.

Definition at line 23 of file Shared.h.

Constructor & Destructor Documentation

Shared() [1/4]

template<typename ElementType>

dash::Shared< ElementType >::Shared ( team_unit_t  owner = team_unit_t(0), Team &  team = dash::Team::All()  )

inline

Constructor, allocates shared value at single unit in specified team.

Parameters

owner	Unit id of the shared value's owner.
team	Team containing all units accessing the element in shared memory

Definition at line 66 of file Shared.h.

References dash::Shared< ElementType >::owner(), and dash::Shared< ElementType >::team().

Referenced by dash::Shared< ElementType >::Shared().

    : Shared(value_type{}, owner, team)
  {
    DASH_LOG_TRACE(
        "Shared.Shared(team,owner) >", "finished delegating constructor");
  }

Shared() [2/4]

template<typename ElementType>

dash::Shared< ElementType >::Shared ( const value_type &  val, team_unit_t  owner = team_unit_t(0), Team &  team = dash::Team::All()  )

inline

Constructor, allocates shared value at single unit in specified team.

The element is initialized with the given value.

Parameters

val	The value to initialize the element with
owner	Unit id of the shared value's owner.
team	Team containing all units accessing the element in shared memory

Definition at line 81 of file Shared.h.

References dash::Shared< ElementType >::init(), dash::is_initialized(), dash::Shared< ElementType >::owner(), dash::Shared< ElementType >::Shared(), and dash::Shared< ElementType >::~Shared().

    : m_team(&team)
    , m_owner(owner)
    , m_memory_resource(nbytes, team)
    , m_allocator(&m_memory_resource)
  {
    DASH_LOG_DEBUG_VAR("Shared.Shared(value,team,owner)()", owner);
    if (dash::is_initialized()) {
      DASH_ASSERT_RETURNS(init(val), true);
    }
  }

~Shared()

template<typename ElementType>

dash::Shared< ElementType >::~Shared ( )

default

Destructor, frees shared memory.

Referenced by dash::Shared< ElementType >::Shared().

Shared() [3/4]

template<typename ElementType>

dash::Shared< ElementType >::Shared ( const self_t &  other )

delete

Copy-constructor: DELETED.

Shared() [4/4]

template<typename ElementType>

dash::Shared< ElementType >::Shared ( self_t &&  other )

inlinenoexcept

Move-constructor.

Transfers ownership from other instance.

Definition at line 112 of file Shared.h.

References dash::Shared< ElementType >::operator=().

    : m_team(other.m_team)
    , m_owner(other.m_owner)
    , m_memory_resource(std::move(other.m_memory_resource))
    , m_allocator(&m_memory_resource)
  {
    auto gptr = other.m_data.release();
    m_data    = unique_gptr_t{
        gptr, typename unique_gptr_t::deleter{m_allocator, nels}};
    DASH_LOG_DEBUG("Shared.Shared(Shared&&) >");
  }

Member Function Documentation

barrier()

template<typename ElementType>

void dash::Shared< ElementType >::barrier ( )

inline

Flush global memory of shared value and synchronize its associated units.

Definition at line 308 of file Shared.h.

References dash::Shared< ElementType >::flush().

  {
    flush();
    DASH_ASSERT(m_team != nullptr);
    m_team->barrier();
  }

dart_gptr()

template<typename ElementType>

dart_gptr_t dash::Shared< ElementType >::dart_gptr ( ) const

inlinenoexcept

Get underlying DART global pointer of the shared variable.

Definition at line 318 of file Shared.h.

  {
    return m_glob_pointer;
  }

flush()

template<typename ElementType>

void dash::Shared< ElementType >::flush ( )

inline

Flush global memory of shared value.

Definition at line 297 of file Shared.h.

References dart_flush(), and DART_OK.

Referenced by dash::Shared< ElementType >::barrier().

  {
    DASH_ASSERT(static_cast<bool>(m_glob_pointer));
    DASH_ASSERT_RETURNS(
        dart_flush(static_cast<dart_gptr_t>(m_glob_pointer)), DART_OK);
  }

get() [1/2]

template<typename ElementType>

reference dash::Shared< ElementType >::get ( )

inline

Get a reference on the shared value.

Definition at line 239 of file Shared.h.

Referenced by dash::io::hdf5::StoreHDF::write().

  {
    DASH_LOG_DEBUG("Shared.cget()");
    DASH_LOG_DEBUG_VAR("Shared.cget", m_owner);
    DASH_LOG_DEBUG_VAR("Shared.get", m_glob_pointer);
    DASH_ASSERT(static_cast<bool>(m_glob_pointer));
    return reference(m_glob_pointer.dart_gptr());
  }

get() [2/2]

template<typename ElementType>

const_reference dash::Shared< ElementType >::get ( ) const

inline

Get a const reference on the shared value.

Definition at line 251 of file Shared.h.

  {
    DASH_LOG_DEBUG("Shared.get()");
    DASH_LOG_DEBUG_VAR("Shared.get", m_owner);
    DASH_LOG_DEBUG_VAR("Shared.get", m_glob_pointer);
    DASH_ASSERT(m_glob_pointer);
    return const_reference(m_glob_pointer.dart_gptr());
  }

init()

template<typename ElementType>

bool dash::Shared< ElementType >::init ( value_type  val = value_type{} )

inline

Collective allocation of a shared variable with an initial value.

NOTE: This call succeeds only once during the lifetime of a single object.

Parameters

the	initial value of the globally shared variable.

Returns

true, if allocation and initialization succeeds. false otherwise.

Definition at line 175 of file Shared.h.

References dart_bcast(), dash::Team::dart_id(), DART_OK, and dash::is_initialized().

Referenced by dash::Shared< ElementType >::Shared().

                                       {})
  {
    if (!dash::is_initialized()) {
      DASH_THROW(
          dash::exception::RuntimeError, "runtime not properly initialized");
    }

    // If our Shared has already a non-null pointer let us return it. The user
    // has first to deallocate it.
    if (m_glob_pointer) {
      DASH_LOG_ERROR("dash::Shared::init", "Shared scalar is already initialized");
      return false;
    }

    // Shared value is only allocated at unit 0:
    if (!m_data && m_team->myid() == m_owner) {
      DASH_LOG_DEBUG(
          "Shared.init(value,team,owner)",
          "allocating shared value in local memory");

      m_data = std::move(dash::allocate_unique<element_t>(m_allocator, nels));

      DASH_ASSERT_MSG(m_data, "null pointer after allocation");

      auto* laddr = static_cast<element_t*>(m_data.get().local());

      // get the underlying allocator for local memory space
      auto local_alloc       = m_memory_resource.get_allocator();
      using allocator_traits = std::allocator_traits<decltype(local_alloc)>;

      // copy construct based on val
      allocator_traits::construct(local_alloc, laddr, element_t{val});
      m_glob_pointer = m_data.get();
    }
    // Broadcast global pointer of shared value at unit 0 to all units:
    dash::dart_storage<pointer_t> ds(nels);

    DASH_ASSERT_RETURNS(
        dart_bcast(
            &m_glob_pointer, ds.nelem, ds.dtype, m_owner, m_team->dart_id()),
        DART_OK);

    DASH_LOG_DEBUG_VAR("Shared.init(value,team,owner) >", m_glob_pointer);
    DASH_LOG_DEBUG("Shared.init(value,team,owner) >");

    return static_cast<bool>(m_glob_pointer);
  }

local() [1/2]

template<typename ElementType>

constexpr value_type const* dash::Shared< ElementType >::local ( ) const

inlinenoexcept

Native pointer to the starting address of the local memory of the unit that initialized this dash::Shared instance.

Definition at line 264 of file Shared.h.

Referenced by dash::broadcast().

  {
    return (m_team->myid() == m_owner) ? m_glob_pointer.local() : nullptr;
  }

local() [2/2]

template<typename ElementType>

value_type* dash::Shared< ElementType >::local ( )

inlinenoexcept

Native pointer to the starting address of the local memory of the unit that initialized this dash::Shared instance.

Definition at line 273 of file Shared.h.

  {
    return (m_team->myid() == m_owner) ? m_glob_pointer.local() : nullptr;
  }

operator=() [1/2]

template<typename ElementType>

self_t& dash::Shared< ElementType >::operator= ( const self_t &  other )

delete

Assignment operator: DELETED.

Referenced by dash::Shared< ElementType >::Shared().

operator=() [2/2]

template<typename ElementType>

self_t& dash::Shared< ElementType >::operator= ( self_t &&  other )

inline

Move-assignment operator.

Definition at line 132 of file Shared.h.

  {
    if (this == &other) {
      return *this;
    }

    m_team  = other.m_team;
    m_owner = other.m_owner;
    // a) release old resources with current memory resource
    m_data.reset();

    // b) move the memory resource
    m_memory_resource = std::move(other.m_memory_resource);
    // do no move the allocator because we already have one...
    DASH_ASSERT_EQ(
        m_allocator.resource(),
        &m_memory_resource,
        "invalid state in move assignment");

    // c) move the data, set pointer
    m_data.reset(other.m_data.release());

    m_glob_pointer = other.m_glob_pointer;

    if (m_team->myid() == m_owner) {
      DASH_ASSERT_EQ(
          m_glob_pointer, m_data.get(), "invalid state in move assignment");
    }

    DASH_LOG_DEBUG("Shared.Shared(Shared&&) >");
    return *this;
  }

owner()

template<typename ElementType>

dash::team_unit_t dash::Shared< ElementType >::owner ( ) const

inlinenoexcept

The unit owning the memory in the global address space.

Definition at line 281 of file Shared.h.

Referenced by dash::broadcast(), and dash::Shared< ElementType >::Shared().

  {
    return m_owner;
  }

set()

template<typename ElementType>

void dash::Shared< ElementType >::set ( const value_type &  val )

inline

Set the value of the shared element.

Definition at line 226 of file Shared.h.

Referenced by dash::io::hdf5::StoreHDF::write().

  {
    DASH_LOG_DEBUG("Shared.set()");
    DASH_LOG_DEBUG_VAR("Shared.set", m_owner);
    DASH_LOG_DEBUG_VAR("Shared.set", m_glob_pointer);
    DASH_ASSERT(m_glob_pointer);
    this->get().set(val);
    DASH_LOG_DEBUG("Shared.set >");
  }

team()

template<typename ElementType>

dash::Team& dash::Shared< ElementType >::team ( ) const

inlinenoexcept

The dash::Team that created this shared object.

Definition at line 289 of file Shared.h.

Referenced by dash::broadcast(), and dash::Shared< ElementType >::Shared().

  {
    return *m_team;
  }

---

The documentation for this class was generated from the following file:

• /tmp/tmporruphar/dash/include/dash/Shared.h