STAPL: stapl::vector_directory< Partition, Mapper, Manager, Registry

The container directory is responsible for distributed metadata for GIDs. It knows in which location GIDs reside. It also provides methods to invoke arbitrary functors on the location of GIDs without requiring external entities to know exact locality information. More...

Public Member Functions
template<typename K >
void	register_keys_impl (std::pair< K, K > const &keys, const location_type loc)
	Associate a set of GIDs in the registry on this location with a specified location. This method should only be called on the location that is responsible for the range of GIDs according to the manager. More...

	vector_directory (size_t block_size=10)
	Create a directory not with an explicit partition and mapper, but with a given block size used to aggregate GIDs. More...

	vector_directory (partition_type const &partition, mapper_type const &mapper)
	Create a directory with an explicit partition and mapper. This partition and mapping information specifies the original distribution, but does not necessarily correlate to future insertions or deletions. More...

template<typename PartitionContainer >
	vector_directory (PartitionContainer const *const part_cont, partition_type const &partition, mapper_type const &mapper)
	Create a directory with an explicit arbitrary distribution specification. The partition and mapping information specifies the original distribution, but does not necessarily correlate to future insertions or deletions. More...

	vector_directory (manager_type const &manager)
	Create a directory with a given manager. More...

	vector_directory (partition_type const &partition, mapper_type const &mapper, manager_type const &manager)
	Create a directory with a given manager, partitioner and mapper. More...

partition_type const &	partition (void) const
	Return the partition for the container.

partition_type &	partition (void)
	Return the partition for the container.

mapper_type const &	mapper (void) const
	Return the mapper for the container.

mapper_type &	mapper (void)

manager_type const &	manager (void) const
	Return the manager of the directory.

template<typename Keys >
void	register_keys (Keys const &keys)
	Associate a set of GIDs in this directory's registry with the value of the location invoking this method. More...

void	erase (key_type const &key, key_type const &last, promise< void > signal)
	Adjust gid to location mappings caused by erasure of gid `key` from the container with current last gid `last`. Then signal completion to vector_distribution::erase via the promise `signal`.

void	insert (key_type const &key, key_type const &last, promise< void > signal)
	Adjust gid to location mappings caused by insertion of a value at gid `key` from the container with current last gid `last`. Then signal completion to vector_distribution::insert via the promise `signal`.

bool	is_registered_local (key_type const &key) const
	Return whether or not a certain GID is registered on the location invoking this method. More...

bool	is_registered (key_type const &key) const
	Return whether or not a certain GID is registered on every location. More...

template<typename NewPartition , typename NewMapper >
void	redistribute (NewPartition const &partition, NewMapper const &mapper, typename std::enable_if< std::is_same< NewPartition, Partition >::value &&std::is_same< NewMapper, Mapper >::value >::type *=0)
	Overwrite the partition and mapper members of the manager and registry with the values provided. More...

template<typename Functor >
void	decreasing_invoke_where (Functor &&f, key_type const &key)
	Invoke function object at the location where key is currently registered; if the key has been unregistered at its managing location, try invoking at the location where key-1 should be registered. More...

bool	has_perfect_mapper (void) const

mapper_t const &	key_mapper (void) const

mapper_t &	key_mapper (void)

bool	empty (void) const
	Returns `true` if there are no entries in directory's registry on this location.

void	reset (void)
	Clear all local registrations and pending messages in directory. Used by `clear()` methods of container distributions.

bool	try_register_key_local (Partition::value_type::index_type const &key)
	Attempt registration from the managing location. Return true if successful (i.e., not already registered).

void	register_key (Partition::value_type::index_type const &key)
	Associate `key` in directory's registry with the location invoking this method. More...

void	register_keys (std::pair< Partition::value_type::index_type, Partition::value_type::index_type > const &keys)

void	register_apply (Partition::value_type::index_type const &key, Functor &&f)
	Associate `key` in directory's registry with location invoking this method. Registration location is implicitly set to be caller of this method. More...

void	register_apply (Partition::value_type::index_type const &key, Functor &&f, location_type location)
	Associate `key` in directory's registry with location invoking this method. More...

void	unregister_key (Partition::value_type::index_type const &key)
	Unregister `key` in directory's registry.

void	unregister_apply (Partition::value_type::index_type const &key, Functor &&f)
	Unregister `key` and apply a function object `f` at location where directory's registry manages `key`. More...

void	invoke_where (Functor &&f, Partition::value_type::index_type const &key)
	Invoke function object at the location where key is currently registered. More...

void	try_invoke_where (Functor &&f, Partition::value_type::index_type const &key)
	Invoke function object at the location where key is currently registered if the key is registered. More...

void	unordered_invoke_where (Functor &&f, Partition::value_type::index_type const &key)
	Invoke function object at the location where key is currently registered, disregarding RMI causal ordering. More...

locality_info	locality (Partition::value_type::index_type const &key)
	Provide locality information about a key managed by the directory. More...

runtime::location_md const &	get_location_md (void) const noexcept
	Returns the location metadata of the location this object registered in.

runtime::location_md &	get_location_md (void) noexcept
	Returns the location metadata of the location this object registered in. noexcept More...

Distributed Object Management
rmi_handle::const_reference const &	get_rmi_handle (void) const noexcept
	Returns the associated rmi_handle.

rmi_handle::reference const &	get_rmi_handle (void) noexcept
	Returns the associated rmi_handle.

size_type	get_location_id (void) const noexcept
	Returns the location id of the local sub-object.

size_type	get_num_locations (void) const noexcept
	Returns the number of locations of the gang of this p_object.

void	advance_epoch (void)
	Advances the epoch of the object. More...

void	unlock (void)
	Used by `lock_guard` functionality in method of derived classes to request atomicity with respect to incoming RMIs. More...

void	lock (void)
	Used by `lock_guard` functionality in method of derived classes to request atomicity with respect to incoming RMIs. More...

bool	try_lock (void)
	Attempt to maintain atomicity with respect to incoming RMIs. More...

Public Types
enum	action_type { INSERT, DELETE }
	Location type. More...

typedef Partition	partition_type

typedef Mapper	mapper_type

typedef partition_type::value_type::index_type	key_type
	GID type.

using	manager_type = mapper_t

using	registry_type = registry_t

using	size_type = rmi_handle::size_type

Protected Member Functions
template<typename Functor >
void	decreasing_request_forward (key_type const &key, Functor &&f)
	Internal method used to facilitate invocation of `f` on location where `key` is currently registered. If `key` is not registered at the expected location, retries to invoke `f` at the location where `key-1` is expected to be registered. More...

void	execute (Functor &&f)
	Internal method, target of RMI called via migrate_impl to invoke functor `f` at new registration location, post registry update. More...

void	invoke_at_manager (Partition::value_type::index_type const &key, void(Directory::*const pmf)(PMFArgs...), Args &&... args)
	Forwards functor and arguments to location managing `key`. The location managing the key will invoke the method with the supplied arguments. More...

void	invoke_at_manager (Partition::value_type::index_type const &key, void(Directory::*const pmf)(PMFArgs...) const, Args &&... args) const
	Forwards const functor and arguments to location managing `key`. The location managing the key will invoke the method with the supplied arguments. More...

void	invoke_at_manager_impl (Partition::value_type::index_type const &key, void(Directory::*const pmf)(PMFArgs...), Args &&... args)
	Implementation of. More...

void	invoke_at_manager_impl (Partition::value_type::index_type const &key, void(Directory::*const pmf)(PMFArgs...) const, Args &&... args) const
	Implementation of. More...

void	flush_pending (const location_type loc, Partition::value_type::index_type const &key, queue_t &pending)
	Forward all buffered requests for `key` to location `loc.` More...

void	request_forward (Partition::value_type::index_type const &key, Functor &&f)
	Internal method used to facilitate invocation of `f` on location where `key` is currently registered. Called via RMI on directory location where `key` is managed. More...

void	try_request_forward (Partition::value_type::index_type const &key, Functor &&f)
	Internal method used to facilitate invocation of `f` on location where `key` is currently registered. If `key` is not registered, the request is dropped; otherwise, it is called via RMI on directory location where `key` is managed. This is directed at situations where it is legal for a key to not exist, i.e. erasing non-existent keys in the unordered set container. More...

Protected Types
using	mapper_t = typename select_parameter< select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type, detail::default_key_mapper< Partition::value_type::index_type > >::type

using	registry_t = typename select_parameter< select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type, boost::unordered_map< Partition::value_type::index_type, location_type, boost::hash< Partition::value_type::index_type >, std::equal_to< Partition::value_type::index_type >, pool_allocator< std::pair< Partition::value_type::index_type const, location_type > > > >::type

using	transmitter_type = typename select_parameter< use_default, async_transmitter >::type

using	queue_t = request_queue< request_t >

using	queues_t = boost::unordered_map< Partition::value_type::index_type, queue_t, stapl::hash< Partition::value_type::index_type >, std::equal_to< Partition::value_type::index_type >, pool_allocator< std::pair< Partition::value_type::index_type const, queue_t > > >

Protected Attributes
registry_t	m_registry
	Stores key to locations mapping.

queues_t	m_pending
	Map of queues, indexed by `Key`. Entry for keys exists when messages arrive and must be buffered prior to registration, during migration, etc.

mapper_t	m_key_mapper
	Map a key to location that manages it (i.e., where it has entry in m_registry).

bool	m_b_perfect_mapper

Detailed Description

template<typename Partition, typename Mapper, typename Manager = use_default, typename Registry = use_default>
class stapl::vector_directory< Partition, Mapper, Manager, Registry >

This directory differs from in that it supports dynamic containers that insert and remove elements.

Template Parameters

Partition	The partition used by the container
Mapper	The mapper used by the container
Manager	A function object that maps GIDs to locations that are responsible for knowing exact locality about that GID. The default manager directory_impl::manager, which uses the partition and mapper information to perform the mapping.
Registry	Storage that maps GIDs to locations. This is the exact locality information for a GID. Default registry is directory_registry.

Member Enumeration Documentation

◆ action_type

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

enum stapl::vector_directory::action_type

Location type.

Used to distinguish between insertion and deletion of elements

Constructor & Destructor Documentation

◆ vector_directory() [1/5]

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

stapl::vector_directory< Partition, Mapper, Manager, Registry >::vector_directory ( size_t block_size = 10 )

Create a directory not with an explicit partition and mapper, but with a given block size used to aggregate GIDs.

This block size designates coarse blocks of GID registration in a cyclic manner. For example, if the block size is 2 and the set of locations is {L0, L1, L2}, then the manager information will be:

([0..1], L0), ([2..3], L1), ([4..5], L2), ([6..7], L0), ...

This constructor has the assumption that the manager takes a single parameter that is the block size, and the registry takes a single parameter which is the manager.

Parameters

block_size The number of GIDs that will be aggregated

◆ vector_directory() [2/5]

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

stapl::vector_directory< Partition, Mapper, Manager, Registry >::vector_directory	(	partition_type const &	partition,
		mapper_type const &	mapper
	)

Create a directory with an explicit partition and mapper. This partition and mapping information specifies the original distribution, but does not necessarily correlate to future insertions or deletions.

Parameters

partition	The container's partition
mapper	The container's mapper

◆ vector_directory() [3/5]

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

template<typename PartitionContainer >

stapl::vector_directory< Partition, Mapper, Manager, Registry >::vector_directory	(	PartitionContainer const *const	part_cont,
		partition_type const &	partition,
		mapper_type const &	mapper
	)

Create a directory with an explicit arbitrary distribution specification. The partition and mapping information specifies the original distribution, but does not necessarily correlate to future insertions or deletions.

Parameters

part_cont	Container of arb_partition_info elements that specifies an arbitrary distribution
partition	The container's partition
mapper	The container's mapper

◆ vector_directory() [4/5]

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

stapl::vector_directory< Partition, Mapper, Manager, Registry >::vector_directory ( manager_type const & manager )

Create a directory with a given manager.

Parameters

manager Manager that this directory will use.

◆ vector_directory() [5/5]

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

stapl::vector_directory< Partition, Mapper, Manager, Registry >::vector_directory	(	partition_type const &	partition,
		mapper_type const &	mapper,
		manager_type const &	manager
	)

Create a directory with a given manager, partitioner and mapper.

Parameters

partition	Partition that this directory will use.
mapper	Mapper that this directory will use.
manager	Manager that this directory will use.

Member Function Documentation

◆ register_keys_impl()

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

template<typename K >

void stapl::vector_directory< Partition, Mapper, Manager, Registry >::register_keys_impl	(	std::pair< K, K > const &	keys,
		const location_type	loc
	)

Associate a set of GIDs in the registry on this location with a specified location. This method should only be called on the location that is responsible for the range of GIDs according to the manager.

Parameters

keys	A collection of GIDS to register, represented as a pair of GIDs defining the lower and upper boundary of a contiguous range.
loc	The location with which to associate the GIDs

◆ register_keys()

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

template<typename Keys >

void stapl::vector_directory< Partition, Mapper, Manager, Registry >::register_keys ( Keys const & keys )

Associate a set of GIDs in this directory's registry with the value of the location invoking this method.

Parameters

keys	A collection of GIDS to register, represented as a pair of GIDs defining the lower and upper boundary of a contiguous range.

◆ is_registered_local()

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

bool stapl::vector_directory< Partition, Mapper, Manager, Registry >::is_registered_local ( key_type const & key ) const

Return whether or not a certain GID is registered on the location invoking this method.

Parameters

key	The GID in question

◆ is_registered()

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

bool stapl::vector_directory< Partition, Mapper, Manager, Registry >::is_registered ( key_type const & key ) const

Return whether or not a certain GID is registered on every location.

Parameters

key	The GID in question

◆ redistribute()

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

template<typename NewPartition , typename NewMapper >

void stapl::vector_directory< Partition, Mapper, Manager, Registry >::redistribute	(	NewPartition const &	partition,
		NewMapper const &	mapper,
		typename std::enable_if< std::is_same< NewPartition, Partition >::value &&std::is_same< NewMapper, Mapper >::value >::type *	= `0`
	)

Overwrite the partition and mapper members of the manager and registry with the values provided.

Redistribution requires use of view-based partition and mapper classes, which have types that are independent of the distribution they implement. This allows the use of is_same to guard the method.

Parameters

partition	View-based partition of the new data distribution.
mapper	View-based mapper of the new data distribution.

◆ decreasing_request_forward()

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

template<typename Functor >

void stapl::vector_directory< Partition, Mapper, Manager, Registry >::decreasing_request_forward	(	key_type const &	key,
		Functor &&	f
	)

protected

Internal method used to facilitate invocation of f on location where key is currently registered. If key is not registered at the expected location, retries to invoke f at the location where key-1 is expected to be registered.

This continues until the location with registered key has been found (in which case f is called via RMI on the appropriate directory location where key is managed) or until all positive keys have been tried. Used in vector_distribution::pop_back.

Parameters

key	Key whose registered location determines where the search for execution location for `f` should be started.
f	Functor to invoke (unary, `key` passed as parameter).

See also: vector_distribution::pop_back

◆ decreasing_invoke_where()

template<typename Partition , typename Mapper , typename Manager = use_default, typename Registry = use_default>

template<typename Functor >

void stapl::vector_directory< Partition, Mapper, Manager, Registry >::decreasing_invoke_where	(	Functor &&	f,
		key_type const &	key
	)

Invoke function object at the location where key is currently registered; if the key has been unregistered at its managing location, try invoking at the location where key-1 should be registered.

Parameters

f	Functor to apply. Unary operator, receives key as parameter.
key	Key that may not be registered when method is invoked

See also: decreasing_request_forward

◆ execute()

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::execute ( Functor && f )

protectedinherited

Internal method, target of RMI called via migrate_impl to invoke functor f at new registration location, post registry update.

Parameters

f	Nullary functor to apply.

See also: migrate_impl()

◆ invoke_at_manager() [1/2]

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::invoke_at_manager	(	Partition::value_type::index_type const &	key,
		void(Directory::*)(PMFArgs...)	pmf,
		Args &&...	args
	)

protectedinherited

Forwards functor and arguments to location managing key. The location managing the key will invoke the method with the supplied arguments.

Parameters

key	Key value whose managing location (i.e., where registry entry is stored) is where `pmf` will be invoked.
pmf	Directory member function to be invoked.
args	variadic list of arguments to be applied.

This is used to internally encapsulate to forward various method invocations from the requester (e.g., registration, invoke_where, etc) to the location where they can be serviced, forwarded, etc.

See also: directory_base::invoke_where

◆ invoke_at_manager() [2/2]

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::invoke_at_manager	(	Partition::value_type::index_type const &	key,
		void(Directory::*)(PMFArgs...) const	pmf,
		Args &&...	args
	)		const

protectedinherited

Forwards const functor and arguments to location managing key. The location managing the key will invoke the method with the supplied arguments.

Parameters

key	Key value whose managing location (i.e., where registry entry is stored) is where `pmf` will be invoked.
pmf	Directory const member function to be invoked.
args	variadic list of arguments to be applied.

This is used to internally encapsulate to forward various method invocations from the requester (e.g., registration, invoke_where, etc) to the location where they can be serviced, forwarded, etc.

See also: directory_base::invoke_where

◆ invoke_at_manager_impl() [1/2]

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::invoke_at_manager_impl	(	Partition::value_type::index_type const &	key,
		void(Directory::*)(PMFArgs...)	pmf,
		Args &&...	args
	)

protectedinherited

Implementation of.

See also: invoke_at_manager with a given transmitter

Template Parameters

Trans The transmitter type

◆ invoke_at_manager_impl() [2/2]

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::invoke_at_manager_impl	(	Partition::value_type::index_type const &	key,
		void(Directory::*)(PMFArgs...) const	pmf,
		Args &&...	args
	)		const

protectedinherited

Implementation of.

See also: invoke_at_manager with a given transmitter

Template Parameters

Trans The given transmitter type

◆ flush_pending()

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::flush_pending	(	const location_type	loc,
		Partition::value_type::index_type const &	key,
		queue_t &	pending
	)

protectedinherited

Forward all buffered requests for key to location loc.

Parameters

loc	Location to send buffered requests to.
key	Key value buffered requests are for.
pending	Pending queue associated with `Key`.

This is internal method only called on the directory location managing key.

◆ request_forward()

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::request_forward	(	Partition::value_type::index_type const &	key,
		Functor &&	f
	)

protectedinherited

Internal method used to facilitate invocation of f on location where key is currently registered. Called via RMI on directory location where key is managed.

Parameters

key	Key whose registered location determines where `f` should be executed.
f	Functor to invoke (unary, `key` passed as parameter).

Called by invoke_where and execute (the latter when migration enabled).

◆ try_request_forward()

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::try_request_forward	(	Partition::value_type::index_type const &	key,
		Functor &&	f
	)

protectedinherited

Internal method used to facilitate invocation of f on location where key is currently registered. If key is not registered, the request is dropped; otherwise, it is called via RMI on directory location where key is managed. This is directed at situations where it is legal for a key to not exist, i.e. erasing non-existent keys in the unordered set container.

Parameters

key	Key whose registered location determines where `f` should be executed.
f	Functor to invoke (unary, `key` passed as parameter).

Called by invoke_where and execute (the latter when migration enabled).

◆ register_key()

inherited

Associate key in directory's registry with the location invoking this method.

◆ register_apply() [1/2]

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::register_apply	(	Partition::value_type::index_type const &	key,
		Functor &&	f
	)

inherited

Associate key in directory's registry with location invoking this method. Registration location is implicitly set to be caller of this method.

Parameters

key	Key to register.
f	Unary function object (receives `key`) as parameter to call after registration.

◆ register_apply() [2/2]

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::register_apply	(	Partition::value_type::index_type const &	key,
		Functor &&	f,
		location_type	location
	)

inherited

Associate key in directory's registry with location invoking this method.

Parameters

key	Key to registered.
f	Unary function object (receives `key`) as parameter to call after registration.
location	Location this key should be mapped to in the registry.

◆ unregister_apply()

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::unregister_apply	(	Partition::value_type::index_type const &	key,
		Functor &&	f
	)

inherited

Unregister key and apply a function object f at location where directory's registry manages key.

Parameters

key	Key to unregister.
f	Unary function object (receives `key`) as parameter to call after unregistration.

◆ invoke_where()

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::invoke_where	(	Functor &&	f,
		Partition::value_type::index_type const &	key
	)

inherited

Invoke function object at the location where key is currently registered.

Parameters

f	Functor to apply. Unary operator, receives key as parameter.
key	Registered key

◆ try_invoke_where()

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::try_invoke_where	(	Functor &&	f,
		Partition::value_type::index_type const &	key
	)

inherited

Invoke function object at the location where key is currently registered if the key is registered.

Parameters

f	Functor to apply. Unary operator, receives key as parameter.
key	Key that may not be registered when method is invoked

◆ unordered_invoke_where()

void stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::unordered_invoke_where	(	Functor &&	f,
		Partition::value_type::index_type const &	key
	)

inherited

Invoke function object at the location where key is currently registered, disregarding RMI causal ordering.

Parameters

f	Functor to apply. Unary operator, receives key as parameter.
key	Registered key

◆ locality()

locality_info stapl::detail::directory_base< Partition::value_type::index_type , use_default , select_parameter< Manager, directory_impl::manager< Partition, Mapper > >::type , select_parameter< Registry, directory_registry< directory_impl::manager< Partition, Mapper >::gid_type > >::type , EnableMigration >::locality ( Partition::value_type::index_type const & key )

inherited

Provide locality information about a key managed by the directory.

Parameters

key	registered key

Note: Used by containers that inherit / customize directory behavior.

◆ get_location_md()

runtime::location_md& stapl::p_object::get_location_md ( void )

noexceptinherited

Returns the location metadata of the location this object registered in. noexcept

noexcept

◆ advance_epoch()

void stapl::p_object::advance_epoch ( void )

inherited

Advances the epoch of the object.

Advancing the epoch will flush any pending RMIs. It will also increase the epoch of the current gang if the object is not a named object.

◆ unlock()

void stapl::p_object::unlock ( void )

inherited

Used by lock_guard functionality in method of derived classes to request atomicity with respect to incoming RMIs.

Mutates counter in the associated runqueue.

◆ lock()

void stapl::p_object::lock ( void )

inherited

Used by lock_guard functionality in method of derived classes to request atomicity with respect to incoming RMIs.

Mutates counter in the associated runqueue.

◆ try_lock()

bool stapl::p_object::try_lock ( void )

inherited

Attempt to maintain atomicity with respect to incoming RMIs.

Mutates counter in the associated runqueue.

Returns: true if the lock was able to be acquired. false if it is already locked.

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

vector_directory.hpp

Public Member Functions

Public Types

Protected Member Functions

Protected Types

Protected Attributes

Detailed Description

template<typename Partition, typename Mapper, typename Manager = use_default, typename Registry = use_default> class stapl::vector_directory< Partition, Mapper, Manager, Registry >

Member Enumeration Documentation

◆ action_type

Constructor & Destructor Documentation

◆ vector_directory() [1/5]

◆ vector_directory() [2/5]

◆ vector_directory() [3/5]

◆ vector_directory() [4/5]

◆ vector_directory() [5/5]

Member Function Documentation

◆ register_keys_impl()

◆ register_keys()

◆ is_registered_local()

◆ is_registered()

◆ redistribute()

◆ decreasing_request_forward()

◆ decreasing_invoke_where()

◆ execute()

◆ invoke_at_manager() [1/2]

◆ invoke_at_manager() [2/2]

◆ invoke_at_manager_impl() [1/2]

◆ invoke_at_manager_impl() [2/2]

◆ flush_pending()

◆ request_forward()

◆ try_request_forward()

◆ register_key()

◆ register_apply() [1/2]

◆ register_apply() [2/2]

◆ unregister_apply()

◆ invoke_where()

◆ try_invoke_where()

◆ unordered_invoke_where()

◆ locality()

◆ get_location_md()

◆ advance_epoch()

◆ unlock()

◆ lock()

◆ try_lock()

template<typename Partition, typename Mapper, typename Manager = use_default, typename Registry = use_default>
class stapl::vector_directory< Partition, Mapper, Manager, Registry >