madness::WorldContainer< keyT, valueT, hashfunT > Class Template Reference

Makes a distributed container with specified attributes. More...

#include <worlddc.h>

Inheritance diagram for madness::WorldContainer< keyT, valueT, hashfunT >:

Collaboration diagram for madness::WorldContainer< keyT, valueT, hashfunT >:

Public Types
typedef implT::accessor	accessor
typedef implT::const_accessor	const_accessor
typedef Future< const_iterator >	const_futureT
typedef implT::const_iterator	const_iterator
typedef WorldContainer< keyT, valueT, hashfunT >	containerT
typedef Future< iterator >	futureT
typedef WorldContainerImpl< keyT, valueT, hashfunT >	implT
typedef implT::iterator	iterator
typedef implT::pairT	pairT

Public Member Functions
	WorldContainer ()
	Makes an uninitialized container (no communication)
	WorldContainer (const WorldContainer &other)
	Copy constructor is shallow (no communication)
	WorldContainer (World &world, bool do_pending=true, const hashfunT &hf=hashfunT())
	Makes an initialized, empty container with default data distribution (no communication)
	WorldContainer (World &world, const std::shared_ptr< WorldDCPmapInterface< keyT > > &pmap, bool do_pending=true, const hashfunT &hf=hashfunT())
	Makes an initialized, empty container (no communication)
virtual	~WorldContainer ()
	Destructor passes ownership of implementation to world for deferred cleanup.
iterator	begin ()
	Returns an iterator to the beginning of the local data (no communication)
const_iterator	begin () const
	Returns an iterator to the beginning of the local data (no communication)
void	clear ()
	Clears all local data (no communication)
iterator	end ()
	Returns an iterator past the end of the local data (no communication)
const_iterator	end () const
	Returns an iterator past the end of the local data (no communication)
void	erase (const iterator &it)
	Erases entry corresponding to local iterator (no communication)
void	erase (const iterator &start, const iterator &finish)
	Erases range defined by local iterators (no communication)
void	erase (const keyT &key)
	Erases entry from container (non-blocking comm if remote)
bool	find (accessor &acc, const keyT &key)
	Write access to LOCAL value by key. Returns true if found, false otherwise (always false for remote).
Future< iterator >	find (const keyT &key)
	Returns a future iterator (non-blocking communication if key not local)
Future< const_iterator >	find (const keyT &key) const
	Returns a future iterator (non-blocking communication if key not local)
bool	find (const_accessor &acc, const keyT &key) const
	Read access to LOCAL value by key. Returns true if found, false otherwise (always false for remote).
hashfunT &	get_hash () const
	Returns a reference to the hashing functor.
std::shared_ptr< WorldDCPmapInterface< keyT > > &	get_impl ()
const std::shared_ptr< WorldDCPmapInterface< keyT > > &	get_pmap () const
	Returns shared pointer to the process mapping.
World &	get_world () const
	Returns the world associated with this container.
const uniqueidT &	id () const
	Returns the associated unique id ... must be initialized.
bool	insert (accessor &acc, const keyT &key)
	Write access to LOCAL value by key. Returns true if inserted, false if already exists (throws if remote)
bool	insert (const_accessor &acc, const keyT &key)
	Read access to LOCAL value by key. Returns true if inserted, false if already exists (throws if remote)
bool	is_local (const keyT &key) const
	Returns true if the key maps to the local processor (no communication)
containerT &	operator= (const containerT &other)
	Assignment is shallow (no communication)
ProcessID	owner (const keyT &key) const
	Returns processor that logically owns key (no communication)
bool	probe (const keyT &key) const
	Returns true if local data is immediately available (no communication)
void	process_pending ()
	Process pending messages.
void	replace (const keyT &key, const valueT &value)
	Inserts/replaces key+value pair (non-blocking communication if key not local)
void	replace (const pairT &datum)
	Inserts/replaces key+value pair (non-blocking communication if key not local)
template<typename input_iterator >
void	replace (input_iterator &start, input_iterator &end)
	Inserts pairs (non-blocking communication if key(s) not local)
void	replicate (bool fence=true)
	replicates this WorldContainer on all ProcessIDs
void	reset_pmap_to_local ()
	Returns shared pointer to the process mapping.
template<typename memfunT , typename arg1T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, const memfunT &memfun, const arg1T &arg1)
	Sends message "resultT memfun(arg1T)" to item (non-blocking comm if remote)
template<typename memfunT >
Future< MEMFUN_RETURNT(memfunT)>	send (const keyT &key, memfunT memfun)
	Sends message "resultT memfun()" to item (non-blocking comm if remote)
template<typename memfunT >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun) const
	Sends message "resultT memfun() const" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1) const
	Sends message "resultT memfun(arg1T) const" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2)
	Sends message "resultT memfun(arg1T,arg2T)" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2) const
	Sends message "resultT memfun(arg1T,arg2T) const" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3)
	Sends message "resultT memfun(arg1T,arg2T,arg3T)" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3) const
	Sends message "resultT memfun(arg1T,arg2T,arg3T) const" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4)
	Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T)" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4) const
	Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T) const" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5)
	Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T)" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5) const
	Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T) const" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6)
	Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T)" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6) const
	Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T) const" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6, const arg7T &arg7)
	Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T)" to item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	send (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6, const arg7T &arg7) const
	Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T) const" to item (non-blocking comm if remote)
template<typename Archive >
void	serialize (const Archive &ar)
	(de)Serialize — Local data only to/from anything except Buffer*Archive and Parallel*Archive
void	serialize (const archive::BufferInputArchive &ar)
	(de)Serialize — !! ONLY for purpose of interprocess communication
void	serialize (const archive::BufferOutputArchive &ar)
	(de)Serialize — !! ONLY for purpose of interprocess communication
std::size_t	size () const
	Returns the number of local entries (no communication)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6, const arg7T &arg7, const TaskAttributes &attr=TaskAttributes())
	Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T)" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6, const arg7T &arg7, const TaskAttributes &attr=TaskAttributes()) const
	Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T) const" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6, const TaskAttributes &attr=TaskAttributes())
	Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T)" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const arg6T &arg6, const TaskAttributes &attr=TaskAttributes()) const
	Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T) const" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const TaskAttributes &attr=TaskAttributes())
	Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T)" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const arg5T &arg5, const TaskAttributes &attr=TaskAttributes()) const
	Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T) const" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const TaskAttributes &attr=TaskAttributes())
	Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T)" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const arg4T &arg4, const TaskAttributes &attr=TaskAttributes()) const
	Adds task "resultT memfun(arg1T,arg2T,arg3T, arg4T) const" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const TaskAttributes &attr=TaskAttributes())
	Adds task "resultT memfun(arg1T,arg2T,arg3T)" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const arg3T &arg3, const TaskAttributes &attr=TaskAttributes()) const
	Adds task "resultT memfun(arg1T,arg2T,arg3T) const" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const TaskAttributes &attr=TaskAttributes())
	Adds task "resultT memfun(arg1T,arg2T)" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T , typename arg2T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const arg2T &arg2, const TaskAttributes &attr=TaskAttributes()) const
	Adds task "resultT memfun(arg1T,arg2T) const" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const TaskAttributes &attr=TaskAttributes())
	Adds task "resultT memfun(arg1T)" in process owning item (non-blocking comm if remote)
template<typename memfunT , typename arg1T >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const arg1T &arg1, const TaskAttributes &attr=TaskAttributes()) const
	Adds task "resultT memfun(arg1T) const" in process owning item (non-blocking comm if remote)
template<typename memfunT >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const TaskAttributes &attr=TaskAttributes())
	Adds task "resultT memfun()" in process owning item (non-blocking comm if remote)
template<typename memfunT >
Future< REMFUTURE(MEMFUN_RETURNT(memfunT))>	task (const keyT &key, memfunT memfun, const TaskAttributes &attr=TaskAttributes()) const
	Adds task "resultT memfun() const" in process owning item (non-blocking comm if remote)

Private Member Functions
void	check_initialized () const

Private Attributes
std::shared_ptr< implT >	p

Friends
void	swap (WorldContainer &, WorldContainer &)

Detailed Description

template<typename keyT, typename valueT, typename hashfunT = Hash<keyT>>
class madness::WorldContainer< keyT, valueT, hashfunT >

Makes a distributed container with specified attributes.

There is no communication or syncronization associated with making a new container, but every process must invoke the constructor for each container in the same order. This is so that we can assign each container a unique ID without any communication. Since remotely invoked operations may start happening before local construction, messages on not yet constructed containers are buffered pending construction.

Similarly, when a container is destroyed, the actual destruction is deferred until a synchronization point (world.gop.fence()) in order to eliminate the need to fence before destroying every container.

The distribution of data between processes is controlled by the process map (Pmap) class. The default is uniform hashing based upon a strong (Bob Jenkins, lookup3) bytewise hash of the key.

All operations, including constructors and destructors, are non-blocking and return immediately. If communication occurs it is asynchronous, otherwise operations are local.

Member Typedef Documentation

accessor

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

typedef implT::accessor madness::WorldContainer< keyT, valueT, hashfunT >::accessor

const_accessor

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

typedef implT::const_accessor madness::WorldContainer< keyT, valueT, hashfunT >::const_accessor

const_futureT

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

typedef Future<const_iterator> madness::WorldContainer< keyT, valueT, hashfunT >::const_futureT

const_iterator

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

typedef implT::const_iterator madness::WorldContainer< keyT, valueT, hashfunT >::const_iterator

containerT

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

typedef WorldContainer<keyT, valueT, hashfunT> madness::WorldContainer< keyT, valueT, hashfunT >::containerT

futureT

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

typedef Future<iterator> madness::WorldContainer< keyT, valueT, hashfunT >::futureT

implT

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

typedef WorldContainerImpl<keyT, valueT, hashfunT> madness::WorldContainer< keyT, valueT, hashfunT >::implT

iterator

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

typedef implT::iterator madness::WorldContainer< keyT, valueT, hashfunT >::iterator

pairT

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

typedef implT::pairT madness::WorldContainer< keyT, valueT, hashfunT >::pairT

Constructor & Destructor Documentation

WorldContainer() [1/4]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

madness::WorldContainer< keyT, valueT, hashfunT >::WorldContainer ( )

inline

Makes an uninitialized container (no communication)

The container is useless until assigned to from a fully constructed container. There is no need to worry about default constructors being executed in order.

WorldContainer() [2/4]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

madness::WorldContainer< keyT, valueT, hashfunT >::WorldContainer ( World &  world, bool  do_pending = true, const hashfunT &  hf = hashfunT()  )

inline

Makes an initialized, empty container with default data distribution (no communication)

A unique ID is associated with every distributed container within a world. In order to avoid synchronization when making a container, we have to assume that all processes execute this constructor in the same order (does not apply to the non-initializing, default constructor).

References madness::WorldContainer< keyT, valueT, hashfunT >::p.

WorldContainer() [3/4]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

madness::WorldContainer< keyT, valueT, hashfunT >::WorldContainer ( World &  world, const std::shared_ptr< WorldDCPmapInterface< keyT > > &  pmap, bool  do_pending = true, const hashfunT &  hf = hashfunT()  )

inline

Makes an initialized, empty container (no communication)

A unique ID is associated with every distributed container within a world. In order to avoid synchronization when making a container, we have to assume that all processes execute this constructor in the same order (does not apply to the non-initializing, default constructor).

References madness::WorldContainer< keyT, valueT, hashfunT >::p.

WorldContainer() [4/4]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

madness::WorldContainer< keyT, valueT, hashfunT >::WorldContainer ( const WorldContainer< keyT, valueT, hashfunT > &  other )

inline

Copy constructor is shallow (no communication)

The copy refers to exactly the same container as other which must be initialized.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized().

~WorldContainer()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

virtual madness::WorldContainer< keyT, valueT, hashfunT >::~WorldContainer ( )

inlinevirtual

Destructor passes ownership of implementation to world for deferred cleanup.

References madness::detail::deferred_cleanup(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Member Function Documentation

begin() [1/2]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

iterator madness::WorldContainer< keyT, valueT, hashfunT >::begin ( )

inline

Returns an iterator to the beginning of the local data (no communication)

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::FunctionImpl(), madness::FunctionImpl< T, NDIM >::add_keys_to_map(), madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::FunctionImpl< T, NDIM >::copy_coeffs(), madness::FunctionImpl< T, NDIM >::do_dirac_convolution(), madness::FunctionImpl< T, NDIM >::errsq_local(), madness::FunctionImpl< T, NDIM >::flo_unary_op_node_inplace(), madness::FunctionImpl< T, NDIM >::flo_unary_op_node_inplace(), madness::FunctionImpl< T, NDIM >::gaxpy(), madness::FunctionImpl< T, NDIM >::gaxpy_inplace(), madness::FunctionImpl< T, NDIM >::get_contraction_node_lists(), madness::FunctionImpl< T, NDIM >::inner_adaptive_local(), madness::FunctionImpl< T, NDIM >::inner_ext_local(), madness::LoadBalanceDeux< NDIM >::load_balance(), madness::FunctionImpl< T, NDIM >::multi_to_multi_op_values(), madness::FunctionImpl< T, NDIM >::multiop_values(), madness::FunctionImpl< T, NDIM >::project(), madness::WorldContainer< keyT, valueT, hashfunT >::serialize(), madness::archive::ArchiveStoreImpl< ParallelOutputArchive< VectorOutputArchive >, WorldContainer< keyT, valueT > >::store(), madness::LoadBalanceDeux< NDIM >::sum(), madness::FunctionImpl< T, NDIM >::unary_op_coeff_inplace(), madness::FunctionImpl< T, NDIM >::unary_op_node_inplace(), and madness::FunctionImpl< T, NDIM >::unary_op_value_inplace().

begin() [2/2]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

const_iterator madness::WorldContainer< keyT, valueT, hashfunT >::begin ( ) const

inline

Returns an iterator to the beginning of the local data (no communication)

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

check_initialized()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized ( ) const

inlineprivate

References MADNESS_ASSERT, and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::WorldContainer< keyT, valueT, hashfunT >::WorldContainer(), madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::WorldContainer< keyT, valueT, hashfunT >::clear(), madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldContainer< keyT, valueT, hashfunT >::erase(), madness::WorldContainer< keyT, valueT, hashfunT >::erase(), madness::WorldContainer< keyT, valueT, hashfunT >::erase(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::WorldContainer< keyT, valueT, hashfunT >::get_hash(), madness::WorldContainer< keyT, valueT, hashfunT >::get_impl(), madness::WorldContainer< keyT, valueT, hashfunT >::get_pmap(), madness::WorldContainer< keyT, valueT, hashfunT >::get_world(), madness::WorldContainer< keyT, valueT, hashfunT >::id(), madness::WorldContainer< keyT, valueT, hashfunT >::insert(), madness::WorldContainer< keyT, valueT, hashfunT >::insert(), madness::WorldContainer< keyT, valueT, hashfunT >::is_local(), madness::WorldContainer< keyT, valueT, hashfunT >::operator=(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::probe(), madness::WorldContainer< keyT, valueT, hashfunT >::process_pending(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::serialize(), madness::WorldContainer< keyT, valueT, hashfunT >::serialize(), madness::WorldContainer< keyT, valueT, hashfunT >::size(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), and madness::WorldContainer< keyT, valueT, hashfunT >::task().

clear()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void madness::WorldContainer< keyT, valueT, hashfunT >::clear ( )

inline

Clears all local data (no communication)

Invalidates all iterators

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

end() [1/2]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

iterator madness::WorldContainer< keyT, valueT, hashfunT >::end ( )

inline

Returns an iterator past the end of the local data (no communication)

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::FunctionImpl(), madness::FunctionImpl< T, NDIM >::add_keys_to_map(), madness::FunctionImpl< T, NDIM >::binaryXXa(), madness::FunctionImpl< T, NDIM >::copy_coeffs(), madness::FunctionImpl< T, NDIM >::do_dirac_convolution(), madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::FunctionImpl< T, NDIM >::errsq_local(), madness::FunctionImpl< T, NDIM >::flo_unary_op_node_inplace(), madness::FunctionImpl< T, NDIM >::flo_unary_op_node_inplace(), madness::FunctionImpl< T, NDIM >::gaxpy(), madness::FunctionImpl< T, NDIM >::gaxpy_ext_recursive(), madness::FunctionImpl< T, NDIM >::gaxpy_inplace(), madness::FunctionImpl< T, NDIM >::get_contraction_node_lists(), madness::FunctionImpl< T, NDIM >::inner_adaptive_local(), madness::FunctionImpl< T, NDIM >::inner_ext_local(), madness::LoadBalanceDeux< NDIM >::load_balance(), madness::FunctionImpl< T, NDIM >::mulXXa(), madness::FunctionImpl< T, NDIM >::mulXXveca(), madness::LoadBalanceDeux< NDIM >::print_tree(), madness::FunctionImpl< T, NDIM >::project(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::FunctionImpl< T, NDIM >::scale_oop(), madness::WorldContainer< keyT, valueT, hashfunT >::serialize(), madness::archive::ArchiveStoreImpl< ParallelOutputArchive< VectorOutputArchive >, WorldContainer< keyT, valueT > >::store(), madness::LoadBalanceDeux< NDIM >::sum(), madness::FunctionImpl< T, NDIM >::unary_op_coeff_inplace(), madness::FunctionImpl< T, NDIM >::unary_op_node_inplace(), madness::FunctionImpl< T, NDIM >::unary_op_value_inplace(), walker1(), and walker2().

end() [2/2]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

const_iterator madness::WorldContainer< keyT, valueT, hashfunT >::end ( ) const

inline

Returns an iterator past the end of the local data (no communication)

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), madness::WorldContainer< keyT, valueT, hashfunT >::end(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

erase() [1/3]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void madness::WorldContainer< keyT, valueT, hashfunT >::erase ( const iterator &  it )

inline

Erases entry corresponding to local iterator (no communication)

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

erase() [2/3]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void madness::WorldContainer< keyT, valueT, hashfunT >::erase ( const iterator &  start, const iterator &  finish  )

inline

Erases range defined by local iterators (no communication)

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

erase() [3/3]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void madness::WorldContainer< keyT, valueT, hashfunT >::erase ( const keyT &  key )

inline

Erases entry from container (non-blocking comm if remote)

Missing keys are quietly ignored.

Note that erasing an entry may invalidate iterators on the remote end. This is just the same as what happens when using STL iterators on an STL container in a sequential algorithm.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::innerXX().

find() [1/4]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

bool madness::WorldContainer< keyT, valueT, hashfunT >::find ( accessor &  acc, const keyT &  key  )

inline

Write access to LOCAL value by key. Returns true if found, false otherwise (always false for remote).

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::binaryXXa(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::FunctionImpl< T, NDIM >::gaxpy_ext_recursive(), madness::FunctionImpl< T, NDIM >::inner_ext_recursive(), madness::FunctionImpl< T, NDIM >::multi_to_multi_op_values_doit(), madness::FunctionImpl< T, NDIM >::multiop_values_doit(), madness::FunctionImpl< T, NDIM >::mulXXa(), madness::FunctionImpl< T, NDIM >::mulXXveca(), madness::FunctionImpl< T, NDIM >::project_out_op< LDIM >::operator()(), madness::FunctionImpl< T, NDIM >::do_inner_local< R >::operator()(), madness::FunctionImpl< T, NDIM >::do_check_symmetry_local::operator()(), madness::FunctionImpl< T, NDIM >::do_merge_trees< Q, R >::operator()(), madness::FunctionImpl< T, NDIM >::do_average::operator()(), madness::FunctionImpl< T, NDIM >::partial_inner(), madness::LoadBalanceDeux< NDIM >::print_tree(), madness::FunctionImpl< T, NDIM >::recur_down_for_contraction_map(), madness::FunctionImpl< T, NDIM >::refine_op(), madness::FunctionImpl< T, NDIM >::refine_spawn(), madness::Cloud::replicate(), madness::LoadBalanceDeux< NDIM >::sum(), test_florian(), walker1(), and walker2().

find() [2/4]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

Future< iterator > madness::WorldContainer< keyT, valueT, hashfunT >::find ( const keyT &  key )

inline

Returns a future iterator (non-blocking communication if key not local)

Like an std::map an iterator "points" to an std::pair<const keyT,valueT>.

Refer to Future for info on how to avoid blocking.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

find() [3/4]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

Future< const_iterator > madness::WorldContainer< keyT, valueT, hashfunT >::find ( const keyT &  key ) const

inline

Returns a future iterator (non-blocking communication if key not local)

Like an std::map an iterator "points" to an std::pair<const keyT,valueT>.

Refer to Future for info on how to avoid blocking.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

find() [4/4]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

bool madness::WorldContainer< keyT, valueT, hashfunT >::find ( const_accessor &  acc, const keyT &  key  ) const

inline

Read access to LOCAL value by key. Returns true if found, false otherwise (always false for remote).

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

get_hash()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

hashfunT & madness::WorldContainer< keyT, valueT, hashfunT >::get_hash ( ) const

inline

Returns a reference to the hashing functor.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

get_impl()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

std::shared_ptr< WorldDCPmapInterface< keyT > > & madness::WorldContainer< keyT, valueT, hashfunT >::get_impl ( )

inline

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

get_pmap()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

const std::shared_ptr< WorldDCPmapInterface< keyT > > & madness::WorldContainer< keyT, valueT, hashfunT >::get_pmap ( ) const

inline

Returns shared pointer to the process mapping.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::distribute().

get_world()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

World & madness::WorldContainer< keyT, valueT, hashfunT >::get_world ( ) const

inline

Returns the world associated with this container.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

id()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

const uniqueidT & madness::WorldContainer< keyT, valueT, hashfunT >::id ( ) const

inline

Returns the associated unique id ... must be initialized.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

insert() [1/2]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

bool madness::WorldContainer< keyT, valueT, hashfunT >::insert ( accessor &  acc, const keyT &  key  )

inline

Write access to LOCAL value by key. Returns true if inserted, false if already exists (throws if remote)

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::WorldContainer< keyT, valueT, hashfunT >::replace(), and madness::FunctionImpl< T, NDIM >::vtransform_doit().

insert() [2/2]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

bool madness::WorldContainer< keyT, valueT, hashfunT >::insert ( const_accessor &  acc, const keyT &  key  )

inline

Read access to LOCAL value by key. Returns true if inserted, false if already exists (throws if remote)

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

is_local()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

bool madness::WorldContainer< keyT, valueT, hashfunT >::is_local ( const keyT &  key ) const

inline

Returns true if the key maps to the local processor (no communication)

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::do_apply(), madness::FunctionImpl< T, NDIM >::forward_traverse(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::operator()(), madness::insert_op< T, NDIM >::operator()(), madness::LoadBalanceDeux< NDIM >::add_op< T, costT >::operator()(), madness::FunctionImpl< T, NDIM >::partial_inner_contract(), madness::FunctionImpl< T, NDIM >::traverse_tree(), and madness::FunctionImpl< T, NDIM >::vtransform_doit().

operator=()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

containerT & madness::WorldContainer< keyT, valueT, hashfunT >::operator= ( const containerT &  other )

inline

Assignment is shallow (no communication)

The copy refers to exactly the same container as other which must be initialized.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

owner()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

ProcessID madness::WorldContainer< keyT, valueT, hashfunT >::owner ( const keyT &  key ) const

inline

Returns processor that logically owns key (no communication)

Local remapping may have changed its physical location, but all operations should forward correctly.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::FunctionImpl(), madness::CoeffTracker< T, NDIM >::activate(), madness::FunctionImpl< T, NDIM >::apply(), madness::FunctionImpl< T, NDIM >::apply_source_driven(), madness::FunctionImpl< T, NDIM >::binaryXX(), madness::FunctionImpl< T, NDIM >::binaryXXa(), madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::continue_recursion(), madness::FunctionImpl< T, NDIM >::do_dirac_convolution(), madness::FunctionImpl< T, NDIM >::gaxpy_ext(), madness::FunctionImpl< T, NDIM >::gaxpy_ext_recursive(), madness::FunctionImpl< T, NDIM >::gaxpy_inplace_reconstructed(), madness::FunctionImpl< T, NDIM >::hartree_product(), madness::LoadBalanceDeux< NDIM >::load_balance(), madness::FunctionImpl< T, NDIM >::make_Vphi_only(), madness::FunctionImpl< T, NDIM >::multiply(), madness::FunctionImpl< T, NDIM >::mulXX(), madness::FunctionImpl< T, NDIM >::mulXXa(), madness::FunctionImpl< T, NDIM >::mulXXvec(), madness::FunctionImpl< T, NDIM >::mulXXveca(), madness::FunctionImpl< T, NDIM >::partial_inner(), madness::FunctionImpl< T, NDIM >::project_out(), madness::FunctionImpl< T, NDIM >::project_out2(), madness::FunctionImpl< T, NDIM >::recursive_apply(), madness::FunctionImpl< T, NDIM >::recursive_apply(), madness::FunctionImpl< T, NDIM >::refine(), madness::FunctionImpl< T, NDIM >::refine_spawn(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::LoadBalanceDeux< NDIM >::sum(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::FunctionImpl< T, NDIM >::traverse_tree(), madness::FunctionImpl< T, NDIM >::unaryXX(), madness::FunctionImpl< T, NDIM >::unaryXXa(), and madness::FunctionImpl< T, NDIM >::unaryXXvalues().

probe()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

bool madness::WorldContainer< keyT, valueT, hashfunT >::probe ( const keyT &  key ) const

inline

Returns true if local data is immediately available (no communication)

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::project_out_op< LDIM >::operator()(), madness::FunctionImpl< T, NDIM >::do_inner_local< R >::operator()(), and madness::FunctionImpl< T, NDIM >::do_check_symmetry_local::operator()().

process_pending()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void madness::WorldContainer< keyT, valueT, hashfunT >::process_pending ( )

inline

Process pending messages.

If the constructor was given do_pending=false then you must invoke this routine in order to process both prior and future messages.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::FunctionImpl(), and madness::FunctionImpl< T, NDIM >::FunctionImpl().

replace() [1/3]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void madness::WorldContainer< keyT, valueT, hashfunT >::replace ( const keyT &  key, const valueT &  value  )

inline

Inserts/replaces key+value pair (non-blocking communication if key not local)

References madness::WorldContainer< keyT, valueT, hashfunT >::replace().

replace() [2/3]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void madness::WorldContainer< keyT, valueT, hashfunT >::replace ( const pairT &  datum )

inline

Inserts/replaces key+value pair (non-blocking communication if key not local)

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::binaryXXa(), madness::FunctionImpl< T, NDIM >::copy_coeffs(), madness::FunctionImpl< T, NDIM >::do_binary_op(), madness::DerivativeBase< T, NDIM >::do_diff1(), madness::Derivative< T, NDIM >::do_diff2b(), madness::Derivative< T, NDIM >::do_diff2i(), madness::FunctionImpl< T, NDIM >::do_mul(), madness::FunctionImpl< T, NDIM >::gaxpy_ext_recursive(), madness::FunctionImpl< T, NDIM >::multiop_values(), madness::FunctionImpl< T, NDIM >::multiop_values_doit(), madness::FunctionImpl< T, NDIM >::mulXXa(), madness::FunctionImpl< T, NDIM >::mulXXveca(), madness::insert_op< T, NDIM >::operator()(), madness::FunctionImpl< T, NDIM >::do_merge_trees< Q, R >::operator()(), madness::FunctionImpl< T, NDIM >::do_mapdim::operator()(), madness::FunctionImpl< T, NDIM >::do_mirror::operator()(), madness::FunctionImpl< T, NDIM >::do_map_and_mirror::operator()(), madness::FunctionImpl< T, NDIM >::do_average::operator()(), madness::FunctionImpl< T, NDIM >::read_grid(), madness::FunctionImpl< T, NDIM >::read_grid2(), madness::FunctionImpl< T, NDIM >::recur_down_for_contraction_map(), madness::FunctionImpl< T, NDIM >::refine_op(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::FunctionImpl< T, NDIM >::scale_oop(), madness::WorldContainer< keyT, valueT, hashfunT >::serialize(), and madness::FunctionImpl< T, NDIM >::unaryXXa().

replace() [3/3]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename input_iterator >

void madness::WorldContainer< keyT, valueT, hashfunT >::replace ( input_iterator &  start, input_iterator &  end  )

inline

Inserts pairs (non-blocking communication if key(s) not local)

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), madness::WorldContainer< keyT, valueT, hashfunT >::end(), and madness::WorldContainer< keyT, valueT, hashfunT >::insert().

replicate()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void madness::WorldContainer< keyT, valueT, hashfunT >::replicate ( bool  fence = true )

inline

replicates this WorldContainer on all ProcessIDs

References madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::replicate().

reset_pmap_to_local()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void madness::WorldContainer< keyT, valueT, hashfunT >::reset_pmap_to_local ( )

inline

Returns shared pointer to the process mapping.

References madness::WorldContainer< keyT, valueT, hashfunT >::p.

send() [1/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, const memfunT &  memfun, const arg1T &  arg1  )

inline

Sends message "resultT memfun(arg1T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

send() [2/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT >

Future< MEMFUN_RETURNT(memfunT)> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun  )

inline

Sends message "resultT memfun()" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::do_apply(), madness::FunctionImpl< T, NDIM >::do_apply_kernel(), madness::FunctionImpl< T, NDIM >::gaxpy(), madness::LoadBalanceDeux< NDIM >::load_balance(), madness::LoadBalanceDeux< NDIM >::add_op< T, costT >::operator()(), madness::FunctionImpl< T, NDIM >::partial_inner_contract(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), and madness::FunctionImpl< T, NDIM >::vtransform_doit().

send() [3/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun  ) const

inline

Sends message "resultT memfun() const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::send().

send() [4/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1  ) const

inline

Sends message "resultT memfun(arg1T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::send().

send() [5/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2  )

inline

Sends message "resultT memfun(arg1T,arg2T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for both local and remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

send() [6/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2  ) const

inline

Sends message "resultT memfun(arg1T,arg2T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::send().

send() [7/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3  )

inline

Sends message "resultT memfun(arg1T,arg2T,arg3T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for both local and remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

send() [8/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3  ) const

inline

Sends message "resultT memfun(arg1T,arg2T,arg3T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::send().

send() [9/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4  )

inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for both local and remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

send() [10/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4  ) const

inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::send().

send() [11/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const arg5T &  arg5  )

inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for both local and remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

send() [12/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const arg5T &  arg5  ) const

inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::send().

send() [13/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const arg5T &  arg5, const arg6T &  arg6  )

inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for both local and remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

send() [14/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const arg5T &  arg5, const arg6T &  arg6  ) const

inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::send().

send() [15/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const arg5T &  arg5, const arg6T &  arg6, const arg7T &  arg7  )

inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T)" to item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments must be ready for both local and remote messages.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

send() [16/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::send ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const arg5T &  arg5, const arg6T &  arg6, const arg7T &  arg7  ) const

inline

Sends message "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T) const" to item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::send().

serialize() [1/3]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename Archive >

void madness::WorldContainer< keyT, valueT, hashfunT >::serialize ( const Archive &  ar )

inline

(de)Serialize — Local data only to/from anything except Buffer*Archive and Parallel*Archive

Advisable for you to fence before and after this to ensure consistency

References madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), madness::WorldContainer< keyT, valueT, hashfunT >::end(), MADNESS_ASSERT, and madness::WorldContainer< keyT, valueT, hashfunT >::replace().

serialize() [2/3]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void madness::WorldContainer< keyT, valueT, hashfunT >::serialize ( const archive::BufferInputArchive &  ar )

inline

(de)Serialize — !! ONLY for purpose of interprocess communication

This just writes/reads the unique id to/from the Buffer*Archive.

References MADNESS_ASSERT, and madness::WorldContainer< keyT, valueT, hashfunT >::p.

serialize() [3/3]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void madness::WorldContainer< keyT, valueT, hashfunT >::serialize ( const archive::BufferOutputArchive &  ar )

inline

(de)Serialize — !! ONLY for purpose of interprocess communication

This just writes/reads the unique id to/from the Buffer*Archive.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

size()

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

std::size_t madness::WorldContainer< keyT, valueT, hashfunT >::size ( ) const

inline

Returns the number of local entries (no communication)

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::multi_to_multi_op_values(), madness::FunctionImpl< T, NDIM >::multiop_values(), and madness::archive::ArchiveStoreImpl< ParallelOutputArchive< VectorOutputArchive >, WorldContainer< keyT, valueT > >::store().

task() [1/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const arg5T &  arg5, const arg6T &  arg6, const arg7T &  arg7, const TaskAttributes &  attr = TaskAttributes()  )

inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::p, and REMFUTURE.

task() [2/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T , typename arg7T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const arg5T &  arg5, const arg6T &  arg6, const arg7T &  arg7, const TaskAttributes &  attr = TaskAttributes()  ) const

inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T,arg7T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::task().

task() [3/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const arg5T &  arg5, const arg6T &  arg6, const TaskAttributes &  attr = TaskAttributes()  )

inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::p, and REMFUTURE.

task() [4/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T , typename arg6T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const arg5T &  arg5, const arg6T &  arg6, const TaskAttributes &  attr = TaskAttributes()  ) const

inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T,arg6T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::task().

task() [5/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const arg5T &  arg5, const TaskAttributes &  attr = TaskAttributes()  )

inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::p, and REMFUTURE.

task() [6/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T , typename arg5T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const arg5T &  arg5, const TaskAttributes &  attr = TaskAttributes()  ) const

inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T,arg5T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::task().

task() [7/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const TaskAttributes &  attr = TaskAttributes()  )

inline

Adds task "resultT memfun(arg1T,arg2T,arg3T,arg4T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::p, and REMFUTURE.

task() [8/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T , typename arg4T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const arg4T &  arg4, const TaskAttributes &  attr = TaskAttributes()  ) const

inline

Adds task "resultT memfun(arg1T,arg2T,arg3T, arg4T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::task().

task() [9/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const TaskAttributes &  attr = TaskAttributes()  )

inline

Adds task "resultT memfun(arg1T,arg2T,arg3T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::p, and REMFUTURE.

task() [10/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T , typename arg3T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const arg3T &  arg3, const TaskAttributes &  attr = TaskAttributes()  ) const

inline

Adds task "resultT memfun(arg1T,arg2T,arg3T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::task().

task() [11/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const TaskAttributes &  attr = TaskAttributes()  )

inline

Adds task "resultT memfun(arg1T,arg2T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::p, and REMFUTURE.

task() [12/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T , typename arg2T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const arg2T &  arg2, const TaskAttributes &  attr = TaskAttributes()  ) const

inline

Adds task "resultT memfun(arg1T,arg2T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::task().

task() [13/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const TaskAttributes &  attr = TaskAttributes()  )

inline

Adds task "resultT memfun(arg1T)" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::p, and REMFUTURE.

task() [14/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT , typename arg1T >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const arg1T &  arg1, const TaskAttributes &  attr = TaskAttributes()  ) const

inline

Adds task "resultT memfun(arg1T) const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::task().

task() [15/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const TaskAttributes &  attr = TaskAttributes()  )

inline

Adds task "resultT memfun()" in process owning item (non-blocking comm if remote)

If item does not exist it is made with the default constructor.

Future arguments for local tasks can generate dependencies, but for remote tasks all futures must be ready.

Returns a future result (Future<void> may be ignored).

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), MEMFUN_RETURNT, madness::WorldContainer< keyT, valueT, hashfunT >::owner(), and madness::WorldContainer< keyT, valueT, hashfunT >::p.

Referenced by madness::FunctionImpl< T, NDIM >::Vphi_op_NS< opT, LDIM >::accumulate_into_result(), madness::FunctionImpl< T, NDIM >::apply_1d_realspace_push_op(), madness::FunctionImpl< T, NDIM >::do_apply(), madness::FunctionImpl< T, NDIM >::do_apply_kernel(), madness::FunctionImpl< T, NDIM >::do_apply_kernel2(), madness::FunctionImpl< T, NDIM >::do_apply_kernel3(), madness::FunctionImpl< T, NDIM >::do_project_out(), madness::LoadBalanceDeux< NDIM >::add_op< T, costT >::operator()(), madness::FunctionImpl< T, NDIM >::do_accumulate_trees< Q, R >::operator()(), madness::FunctionImpl< T, NDIM >::partial_inner_contract(), madness::LoadBalanceDeux< NDIM >::sum(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), and madness::FunctionImpl< T, NDIM >::vtransform_doit().

task() [16/16]

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

template<typename memfunT >

Future< REMFUTURE(MEMFUN_RETURNT(memfunT))> madness::WorldContainer< keyT, valueT, hashfunT >::task ( const keyT &  key, memfunT  memfun, const TaskAttributes &  attr = TaskAttributes()  ) const

inline

Adds task "resultT memfun() const" in process owning item (non-blocking comm if remote)

The method executes with a write lock on the item.

References madness::WorldContainer< keyT, valueT, hashfunT >::task().

Friends And Related Symbol Documentation

swap

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

void swap ( WorldContainer< keyT, valueT, hashfunT > &  , WorldContainer< keyT, valueT, hashfunT > &    )

friend

Member Data Documentation

p

template<typename keyT , typename valueT , typename hashfunT = Hash<keyT>>

std::shared_ptr<implT> madness::WorldContainer< keyT, valueT, hashfunT >::p

private

Referenced by madness::WorldContainer< keyT, valueT, hashfunT >::WorldContainer(), madness::WorldContainer< keyT, valueT, hashfunT >::WorldContainer(), madness::WorldContainer< keyT, valueT, hashfunT >::~WorldContainer(), madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::WorldContainer< keyT, valueT, hashfunT >::begin(), madness::WorldContainer< keyT, valueT, hashfunT >::check_initialized(), madness::WorldContainer< keyT, valueT, hashfunT >::clear(), madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldContainer< keyT, valueT, hashfunT >::end(), madness::WorldContainer< keyT, valueT, hashfunT >::erase(), madness::WorldContainer< keyT, valueT, hashfunT >::erase(), madness::WorldContainer< keyT, valueT, hashfunT >::erase(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::WorldContainer< keyT, valueT, hashfunT >::find(), madness::WorldContainer< keyT, valueT, hashfunT >::get_hash(), madness::WorldContainer< keyT, valueT, hashfunT >::get_impl(), madness::WorldContainer< keyT, valueT, hashfunT >::get_pmap(), madness::WorldContainer< keyT, valueT, hashfunT >::get_world(), madness::WorldContainer< keyT, valueT, hashfunT >::id(), madness::WorldContainer< keyT, valueT, hashfunT >::insert(), madness::WorldContainer< keyT, valueT, hashfunT >::insert(), madness::WorldContainer< keyT, valueT, hashfunT >::is_local(), madness::WorldContainer< keyT, valueT, hashfunT >::operator=(), madness::WorldContainer< keyT, valueT, hashfunT >::owner(), madness::WorldContainer< keyT, valueT, hashfunT >::probe(), madness::WorldContainer< keyT, valueT, hashfunT >::process_pending(), madness::WorldContainer< keyT, valueT, hashfunT >::replace(), madness::WorldContainer< keyT, valueT, hashfunT >::replicate(), madness::WorldContainer< keyT, valueT, hashfunT >::reset_pmap_to_local(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::send(), madness::WorldContainer< keyT, valueT, hashfunT >::serialize(), madness::WorldContainer< keyT, valueT, hashfunT >::serialize(), madness::WorldContainer< keyT, valueT, hashfunT >::size(), madness::swap(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), madness::WorldContainer< keyT, valueT, hashfunT >::task(), and madness::WorldContainer< keyT, valueT, hashfunT >::task().

---

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

• worlddc.h