A derived classe from DistacneTableData, specialized for dense case. More...

Inheritance diagram for SoaDistanceTableAAOMPTarget< T, D, SC >:

Collaboration diagram for SoaDistanceTableAAOMPTarget< T, D, SC >:

Classes
struct	DTAAMultiWalkerMem
	multi walker shared memory buffer More...

Public Member Functions
	SoaDistanceTableAAOMPTarget (ParticleSet &target)

	SoaDistanceTableAAOMPTarget ()=delete

	SoaDistanceTableAAOMPTarget (const SoaDistanceTableAAOMPTarget &)=delete

	~SoaDistanceTableAAOMPTarget ()

size_t	compute_size (int N) const

void	resize ()

const RealType *	getMultiWalkerTempDataPtr () const override
	return multi walker temporary pair distance table data pointer More...

void	createResource (ResourceCollection &collection) const override
	initialize a shared resource and hand it to a collection More...

void	acquireResource (ResourceCollection &collection, const RefVectorWithLeader< DistanceTable > &dt_list) const override
	acquire a shared resource from a collection More...

void	releaseResource (ResourceCollection &collection, const RefVectorWithLeader< DistanceTable > &dt_list) const override
	return a shared resource to a collection More...

void	evaluate (ParticleSet &P) override
	evaluate the full Distance Table More...

const RealType *	mw_evalDistsInRange (const RefVectorWithLeader< DistanceTable > &dt_list, const RefVectorWithLeader< ParticleSet > &p_list, size_t range_begin, size_t range_end) const override
	compute distances from particles in [range_begin, range_end) to all the particles. More...

void	move (const ParticleSet &P, const PosType &rnew, const IndexType iat, bool prepare_old) override
	evaluate the temporary pair relations More...

void	mw_move (const RefVectorWithLeader< DistanceTable > &dt_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< PosType > &rnew_list, const IndexType iat, bool prepare_old=true) const override
	evaluate the temporary pair relations when a move is proposed this implementation is asynchronous and the synchronization is managed at ParticleSet. More...

int	get_first_neighbor (IndexType iat, RealType &r, PosType &dr, bool newpos) const override

void	update (IndexType iat) override
	After accepting the iat-th particle, update the iat-th row of distances_ and displacements_. More...

void	updatePartial (IndexType jat, bool from_temp) override
	fill partially the distance table by the pair relations from the temporary or old particle position. More...

void	mw_updatePartial (const RefVectorWithLeader< DistanceTable > &dt_list, IndexType jat, const std::vector< bool > &from_temp) override
	walker batched version of updatePartial. More...

void	mw_finalizePbyP (const RefVectorWithLeader< DistanceTable > &dt_list, const RefVectorWithLeader< ParticleSet > &p_list) const override
	walker batched version of finalizePbyP If not DTModes::NEED_TEMP_DATA_ON_HOST, host distance table data is not updated at all during p-by-p Thus, a recompute is necessary to update the whole host distance table for consumers like the Coulomb potential. More...

size_t	get_num_particls_stored () const override

Public Member Functions inherited from DTD_BConds< T, D, SC >
	DTD_BConds (const CrystalLattice< T, D > &lat)
	constructor: doing nothing More...

T	apply_bc (TinyVector< T, D > &displ) const
	apply BC on displ and return \|displ\|^2 More...

void	apply_bc (std::vector< TinyVector< T, D >> &dr, std::vector< T > &r, std::vector< T > &rinv) const
	apply BC on dr and evaluate r and rinv More...

void	apply_bc (std::vector< TinyVector< T, D >> &dr, std::vector< T > &r) const

void	evaluate_rsquared (TinyVector< T, D > restrict dr, T restrict rr, int n)

Public Member Functions inherited from DistanceTableAA
	DistanceTableAA (const ParticleSet &target, DTModes modes)
	constructor using source and target ParticleSet More...

const std::vector< DistRow > &	getDistances () const
	return full table distances More...

const std::vector< DisplRow > &	getDisplacements () const
	return full table displacements More...

const DistRow &	getDistRow (int iel) const
	return a row of distances for a given target particle More...

const DisplRow &	getDisplRow (int iel) const
	return a row of displacements for a given target particle More...

const DistRow &	getTempDists () const
	return the temporary distances when a move is proposed More...

const DisplRow &	getTempDispls () const
	return the temporary displacements when a move is proposed More...

const DistRow &	getOldDists () const
	return old distances set up by move() for optimized distance table consumers More...

const DisplRow &	getOldDispls () const
	return old displacements set up by move() for optimized distance table consumers More...

Public Member Functions inherited from DistanceTable
	DistanceTable (const ParticleSet &source, const ParticleSet &target, DTModes modes)
	constructor using source and target ParticleSet More...

	DistanceTable (const DistanceTable &)=delete
	copy constructor. deleted More...

virtual	~DistanceTable ()=default
	virutal destructor More...

DTModes	getModes () const
	get modes More...

void	setModes (DTModes modes)
	set modes More...

const std::string &	getName () const
	return the name of table More...

const ParticleSet &	get_origin () const
	returns the reference the origin particleset More...

size_t	centers () const
	returns the number of centers More...

size_t	targets () const
	returns the number of centers More...

size_t	sources () const
	returns the number of source particles More...

virtual void	mw_evaluate (const RefVectorWithLeader< DistanceTable > &dt_list, const RefVectorWithLeader< ParticleSet > &p_list) const

virtual void	mw_recompute (const RefVectorWithLeader< DistanceTable > &dt_list, const RefVectorWithLeader< ParticleSet > &p_list, const std::vector< bool > &recompute) const
	recompute multi walker internal data, recompute More...

virtual void	finalizePbyP (const ParticleSet &P)
	finalize distance table calculation after particle-by-particle moves if update() doesn't make the table up-to-date during p-by-p moves finalizePbyP takes action to bring the table up-to-date More...

virtual int	get_first_neighbor (IndexType iat, RealType &r, PosType &dr, bool newpos) const =0
	find the first nearest neighbor More...

void	print (std::ostream &os)

Public Attributes
aligned_vector< RealType >	memory_pool_
	actual memory for dist and displacements_ More...

DistRow	temp_r_mem_
	actual memory for temp_r_ More...

DisplRow	temp_dr_mem_
	actual memory for temp_dr_ More...

DistRow	old_r_mem_
	actual memory for old_r_ More...

DisplRow	old_dr_mem_
	actual memory for old_dr_ More...

ResourceHandle< DTAAMultiWalkerMem >	mw_mem_handle_

Private Attributes
const size_t	num_targets_padded_
	number of targets with padding More...

int	old_prepared_elec_id_
	set to particle id after move() with prepare_old = true. More...

NewTimer &	offload_timer_
	timer for offload portion More...

NewTimer &	evaluate_timer_
	timer for evaluate() More...

NewTimer &	move_timer_
	timer for move() More...

NewTimer &	update_timer_
	timer for update() More...

const size_t	num_particls_stored = 64
	the particle count of the internal stored distances. More...

Additional Inherited Members
Public Types inherited from DistanceTable
using	IndexType = QMCTraits::IndexType

using	RealType = QMCTraits::RealType

using	PosType = QMCTraits::PosType

using	DistRow = Vector< RealType, aligned_allocator< RealType > >

using	DisplRow = VectorSoaContainer< RealType, DIM >

Static Public Attributes inherited from DistanceTable
static constexpr unsigned	DIM = OHMMS_DIM

Protected Attributes inherited from DistanceTableAA
std::vector< DistRow >	distances_
	distances_[num_targets_][num_sources_], [i][3][j] = \|r_A2[j] - r_A1[i]\| Note: Derived classes decide if it is a memory view or the actual storage For only the lower triangle (j<i) data can be accessed safely. More...

std::vector< DisplRow >	displacements_
	displacements_[num_targets_][3][num_sources_], [i][3][j] = r_A2[j] - r_A1[i] Note: Derived classes decide if it is a memory view or the actual storage only the lower triangle (j<i) is defined. More...

DistRow	temp_r_
	temp_r More...

DisplRow	temp_dr_
	temp_dr More...

DistRow	old_r_
	old distances More...

DisplRow	old_dr_
	old displacements More...

Protected Attributes inherited from DistanceTable
const ParticleSet &	origin_

const size_t	num_sources_

const size_t	num_targets_

const std::string	name_
	name of the table More...

DTModes	modes_
	operation modes defined by DTModes More...

Detailed Description

template<typename T, unsigned D, int SC>
struct qmcplusplus::SoaDistanceTableAAOMPTarget< T, D, SC >

A derived classe from DistacneTableData, specialized for dense case.

Definition at line 31 of file SoaDistanceTableAAOMPTarget.h.

Constructor & Destructor Documentation

◆ SoaDistanceTableAAOMPTarget() [1/3]

SoaDistanceTableAAOMPTarget ( ParticleSet & target )

inline

Definition at line 67 of file SoaDistanceTableAAOMPTarget.h.

References ParticleSet::getCoordinates(), and SoaDistanceTableAAOMPTarget< T, D, SC >::resize().

       : DTD_BConds<T, D, SC>(target.getLattice()),
         DistanceTableAA(target, DTModes::ALL_OFF),
         num_targets_padded_(getAlignedSize<T>(num_targets_)),
 #if !defined(NDEBUG)
         old_prepared_elec_id_(-1),
 #endif
         offload_timer_(createGlobalTimer(std::string("DTAAOMPTarget::offload_") + name_, timer_level_fine)),
         evaluate_timer_(createGlobalTimer(std::string("DTAAOMPTarget::evaluate_") + name_, timer_level_fine)),
         move_timer_(createGlobalTimer(std::string("DTAAOMPTarget::move_") + name_, timer_level_fine)),
         update_timer_(createGlobalTimer(std::string("DTAAOMPTarget::update_") + name_, timer_level_fine))
 
   {
     auto* coordinates_soa = dynamic_cast<const RealSpacePositionsOMPTarget*>(&target.getCoordinates());
     if (!coordinates_soa)
       throw std::runtime_error("Source particle set doesn't have OpenMP offload. Contact developers!");
     resize();
     PRAGMA_OFFLOAD("omp target enter data map(to : this[:1])")
   }

◆ SoaDistanceTableAAOMPTarget() [2/3]

SoaDistanceTableAAOMPTarget ( )

delete

◆ SoaDistanceTableAAOMPTarget() [3/3]

SoaDistanceTableAAOMPTarget ( const SoaDistanceTableAAOMPTarget< T, D, SC > & )

delete

◆ ~SoaDistanceTableAAOMPTarget()

~SoaDistanceTableAAOMPTarget ( )

inline

Definition at line 89 of file SoaDistanceTableAAOMPTarget.h.

89 {PRAGMA_OFFLOAD("omp target exit data map(delete : this[:1])")}

Member Function Documentation

◆ acquireResource()

void acquireResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< DistanceTable > &	dt_list
	)		const

inlineoverridevirtual

acquire a shared resource from a collection

Reimplemented from DistanceTable.

Definition at line 127 of file SoaDistanceTableAAOMPTarget.h.

References Vector< T, Alloc >::attachReference(), Vector< T, Alloc >::free(), RefVectorWithLeader< T >::getCastedElement(), RefVectorWithLeader< T >::getCastedLeader(), RefVectorWithLeader< T >::getLeader(), ResourceCollection::lendResource(), SoaDistanceTableAAOMPTarget< T, D, SC >::mw_mem_handle_, DistanceTable::num_targets_, SoaDistanceTableAAOMPTarget< T, D, SC >::num_targets_padded_, and DistanceTableAA::temp_r_.

   {
     assert(this == &dt_list.getLeader());
     auto& dt_leader          = dt_list.getCastedLeader<SoaDistanceTableAAOMPTarget>();
     dt_leader.mw_mem_handle_ = collection.lendResource<DTAAMultiWalkerMem>();
     const size_t nw          = dt_list.size();
     const size_t stride_size = num_targets_padded_ * (D + 1);
 
     for (int iw = 0; iw < nw; iw++)
     {
       auto& dt = dt_list.getCastedElement<SoaDistanceTableAAOMPTarget>(iw);
       dt.temp_r_.free();
       dt.temp_dr_.free();
       dt.old_r_.free();
       dt.old_dr_.free();
     }
 
     auto& mw_new_old_dist_displ = dt_leader.mw_mem_handle_.getResource().mw_new_old_dist_displ;
     mw_new_old_dist_displ.resize(nw * 2 * stride_size);
     for (int iw = 0; iw < nw; iw++)
     {
       auto& dt = dt_list.getCastedElement<SoaDistanceTableAAOMPTarget>(iw);
       dt.temp_r_.attachReference(mw_new_old_dist_displ.data() + stride_size * iw, num_targets_padded_);
       dt.temp_dr_.attachReference(num_targets_, num_targets_padded_,
                                   mw_new_old_dist_displ.data() + stride_size * iw + num_targets_padded_);
       dt.old_r_.attachReference(mw_new_old_dist_displ.data() + stride_size * (iw + nw), num_targets_padded_);
       dt.old_dr_.attachReference(num_targets_, num_targets_padded_,
                                  mw_new_old_dist_displ.data() + stride_size * (iw + nw) + num_targets_padded_);
     }
   }

◆ compute_size()

size_t compute_size ( int N ) const

inline

Definition at line 91 of file SoaDistanceTableAAOMPTarget.h.

References qmcplusplus::Units::force::N.

Referenced by SoaDistanceTableAAOMPTarget< T, D, SC >::resize().

   {
     const size_t num_padded = getAlignedSize<T>(N);
     const size_t Alignment  = getAlignment<T>();
     return (num_padded * (2 * N - num_padded + 1) + (Alignment - 1) * num_padded) / 2;
   }

◆ createResource()

void createResource ( ResourceCollection & collection ) const

inlineoverridevirtual

initialize a shared resource and hand it to a collection

Reimplemented from DistanceTable.

Definition at line 122 of file SoaDistanceTableAAOMPTarget.h.

References ResourceCollection::addResource().

   {
     auto resource_index = collection.addResource(std::make_unique<DTAAMultiWalkerMem>());
   }

◆ evaluate()

void evaluate ( ParticleSet & P )

inlineoverridevirtual

evaluate the full Distance Table

Parameters

P	the target particle set

Implements DistanceTable.

Definition at line 172 of file SoaDistanceTableAAOMPTarget.h.

References DistanceTableAA::displacements_, DistanceTableAA::distances_, SoaDistanceTableAAOMPTarget< T, D, SC >::evaluate_timer_, DynamicCoordinates::getAllParticlePos(), ParticleSet::getCoordinates(), DistanceTable::num_targets_, and ParticleSet::R.

   {
     ScopedTimer local_timer(evaluate_timer_);
 
     constexpr T BigR = std::numeric_limits<T>::max();
     for (int iat = 1; iat < num_targets_; ++iat)
       DTD_BConds<T, D, SC>::computeDistances(P.R[iat], P.getCoordinates().getAllParticlePos(), distances_[iat].data(),
                                              displacements_[iat], 0, iat, iat);
   }

◆ get_first_neighbor()

int get_first_neighbor	(	IndexType	iat,
		RealType &	r,
		PosType &	dr,
		bool	newpos
	)		const

inlineoverride

Definition at line 376 of file SoaDistanceTableAAOMPTarget.h.

References DistanceTableAA::displacements_, DistanceTableAA::distances_, DistanceTable::num_targets_, DistanceTableAA::temp_dr_, and DistanceTableAA::temp_r_.

   {
     //ensure there are neighbors
     assert(num_targets_ > 1);
     RealType min_dist = std::numeric_limits<RealType>::max();
     int index         = -1;
     if (newpos)
     {
       for (int jat = 0; jat < num_targets_; ++jat)
         if (temp_r_[jat] < min_dist && jat != iat)
         {
           min_dist = temp_r_[jat];
           index    = jat;
         }
       assert(index >= 0);
       dr = temp_dr_[index];
     }
     else
     {
       for (int jat = 0; jat < iat; ++jat)
         if (distances_[iat][jat] < min_dist)
         {
           min_dist = distances_[iat][jat];
           index    = jat;
         }
       for (int jat = iat + 1; jat < num_targets_; ++jat)
         if (distances_[jat][iat] < min_dist)
         {
           min_dist = distances_[jat][iat];
           index    = jat;
         }
       assert(index != iat && index >= 0);
       if (index < iat)
         dr = displacements_[iat][index];
       else
         dr = displacements_[index][iat];
     }
     r = min_dist;
     return index;
   }

◆ get_num_particls_stored()

size_t get_num_particls_stored ( ) const

inlineoverridevirtual

Reimplemented from DistanceTableAA.

Definition at line 484 of file SoaDistanceTableAAOMPTarget.h.

References SoaDistanceTableAAOMPTarget< T, D, SC >::num_particls_stored.

484 { return num_particls_stored; }

qmcplusplus::SoaDistanceTableAAOMPTarget::num_particls_stored

const size_t num_particls_stored

the particle count of the internal stored distances.

Definition: SoaDistanceTableAAOMPTarget.h:504

◆ getMultiWalkerTempDataPtr()

const RealType* getMultiWalkerTempDataPtr ( ) const

inlineoverridevirtual

return multi walker temporary pair distance table data pointer

Reimplemented from DistanceTableAA.

Definition at line 117 of file SoaDistanceTableAAOMPTarget.h.

References SoaDistanceTableAAOMPTarget< T, D, SC >::mw_mem_handle_.

   {
     return mw_mem_handle_.getResource().mw_new_old_dist_displ.data();
   }

◆ move()

void move	(	const ParticleSet &	P,
		const PosType &	rnew,
		const IndexType	iat,
		bool	prepare_old
	)

inlineoverridevirtual

evaluate the temporary pair relations

Implements DistanceTable.

Definition at line 257 of file SoaDistanceTableAAOMPTarget.h.

References Vector< T, Alloc >::attachReference(), VectorSoaContainer< T, D, Alloc >::attachReference(), VectorSoaContainer< T, D, Alloc >::capacity(), Vector< T, Alloc >::data(), VectorSoaContainer< T, D, Alloc >::data(), DynamicCoordinates::getAllParticlePos(), ParticleSet::getCoordinates(), SoaDistanceTableAAOMPTarget< T, D, SC >::move_timer_, DistanceTable::num_targets_, DistanceTableAA::old_dr_, SoaDistanceTableAAOMPTarget< T, D, SC >::old_dr_mem_, SoaDistanceTableAAOMPTarget< T, D, SC >::old_prepared_elec_id_, DistanceTableAA::old_r_, SoaDistanceTableAAOMPTarget< T, D, SC >::old_r_mem_, ParticleSet::R, Vector< T, Alloc >::size(), VectorSoaContainer< T, D, Alloc >::size(), DistanceTableAA::temp_dr_, SoaDistanceTableAAOMPTarget< T, D, SC >::temp_dr_mem_, DistanceTableAA::temp_r_, and SoaDistanceTableAAOMPTarget< T, D, SC >::temp_r_mem_.

   {
     ScopedTimer local_timer(move_timer_);
 
 #if !defined(NDEBUG)
     old_prepared_elec_id_ = prepare_old ? iat : -1;
 #endif
     temp_r_.attachReference(temp_r_mem_.data(), temp_r_mem_.size());
     temp_dr_.attachReference(temp_dr_mem_.size(), temp_dr_mem_.capacity(), temp_dr_mem_.data());
 
     assert((prepare_old && iat >= 0 && iat < num_targets_) || !prepare_old);
     DTD_BConds<T, D, SC>::computeDistances(rnew, P.getCoordinates().getAllParticlePos(), temp_r_.data(), temp_dr_, 0,
                                            num_targets_, iat);
     // set up old_r_ and old_dr_ for moves may get accepted.
     if (prepare_old)
     {
       old_r_.attachReference(old_r_mem_.data(), old_r_mem_.size());
       old_dr_.attachReference(old_dr_mem_.size(), old_dr_mem_.capacity(), old_dr_mem_.data());
       //recompute from scratch
       DTD_BConds<T, D, SC>::computeDistances(P.R[iat], P.getCoordinates().getAllParticlePos(), old_r_.data(), old_dr_,
                                              0, num_targets_, iat);
       old_r_[iat] = std::numeric_limits<T>::max(); //assign a big number
     }
   }

◆ mw_evalDistsInRange()

const RealType* mw_evalDistsInRange	(	const RefVectorWithLeader< DistanceTable > &	dt_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		size_t	range_begin,
		size_t	range_end
	)		const

inlineoverridevirtual

compute distances from particles in [range_begin, range_end) to all the particles.

Although [range_begin, range_end) and be any particle [0, num_sources), it is only necessary to compute half of the table due to the symmetry of AA table. See note of the output data object mw_distances_subset To keep resident memory minimal on the device, range_end - range_begin < num_particls_stored is required.

Reimplemented from DistanceTableAA.

Definition at line 187 of file SoaDistanceTableAAOMPTarget.h.

References RefVectorWithLeader< T >::getCastedLeader(), RefVectorWithLeader< T >::getLeader(), RealSpacePositionsOMPTarget::getMultiWalkerRSoADevicePtrs(), omptarget::min(), and SoaDistanceTableAAOMPTarget< T, D, SC >::DTAAMultiWalkerMem::mw_distances_subset.

   {
     auto& dt_leader          = dt_list.getCastedLeader<SoaDistanceTableAAOMPTarget>();
     const size_t subset_size = range_end - range_begin;
     if (subset_size > dt_leader.num_particls_stored)
       throw std::runtime_error("not enough internal buffer");
 
     ScopedTimer local_timer(dt_leader.evaluate_timer_);
 
     DTAAMultiWalkerMem& mw_mem = dt_leader.mw_mem_handle_;
     auto& pset_leader          = p_list.getLeader();
 
     const size_t nw              = dt_list.size();
     const auto num_sources_local = dt_leader.num_targets_;
     const auto num_padded        = dt_leader.num_targets_padded_;
     mw_mem.mw_distances_subset.resize(nw * subset_size * num_padded);
 
     const int ChunkSizePerTeam = 512;
     const size_t num_teams     = (num_sources_local + ChunkSizePerTeam - 1) / ChunkSizePerTeam;
 
     auto& coordinates_leader = static_cast<const RealSpacePositionsOMPTarget&>(pset_leader.getCoordinates());
 
     auto* rsoa_dev_list_ptr = coordinates_leader.getMultiWalkerRSoADevicePtrs().data();
     auto* dist_ranged       = mw_mem.mw_distances_subset.data();
     {
       ScopedTimer offload(dt_leader.offload_timer_);
       PRAGMA_OFFLOAD("omp target teams distribute collapse(2) num_teams(nw * num_teams)")
       for (int iw = 0; iw < nw; ++iw)
         for (int team_id = 0; team_id < num_teams; team_id++)
         {
           auto* source_pos_ptr = rsoa_dev_list_ptr[iw];
           const size_t first   = ChunkSizePerTeam * team_id;
           const size_t last    = omptarget::min(first + ChunkSizePerTeam, num_sources_local);
 
           PRAGMA_OFFLOAD("omp parallel for")
           for (int iel = first; iel < last; iel++)
           {
             for (int irow = 0; irow < subset_size; irow++)
             {
               T* dist          = dist_ranged + (irow + subset_size * iw) * num_padded;
               size_t id_target = irow + range_begin;
 
               T dx, dy, dz;
               if (id_target < iel)
               {
                 dx = source_pos_ptr[id_target] - source_pos_ptr[iel];
                 dy = source_pos_ptr[id_target + num_padded] - source_pos_ptr[iel + num_padded];
                 dz = source_pos_ptr[id_target + num_padded * 2] - source_pos_ptr[iel + num_padded * 2];
               }
               else
               {
                 const size_t id_target_reverse = num_sources_local - 1 - id_target;
                 const size_t iel_reverse       = num_sources_local - 1 - iel;
                 dx                             = source_pos_ptr[id_target_reverse] - source_pos_ptr[iel_reverse];
                 dy = source_pos_ptr[id_target_reverse + num_padded] - source_pos_ptr[iel_reverse + num_padded];
                 dz = source_pos_ptr[id_target_reverse + num_padded * 2] - source_pos_ptr[iel_reverse + num_padded * 2];
               }
 
               dist[iel] = DTD_BConds<T, D, SC>::computeDist(dx, dy, dz);
             }
           }
         }
     }
     return mw_mem.mw_distances_subset.data();
   }

◆ mw_finalizePbyP()

void mw_finalizePbyP	(	const RefVectorWithLeader< DistanceTable > &	dt_list,
		const RefVectorWithLeader< ParticleSet > &	p_list
	)		const

inlineoverridevirtual

walker batched version of finalizePbyP If not DTModes::NEED_TEMP_DATA_ON_HOST, host distance table data is not updated at all during p-by-p Thus, a recompute is necessary to update the whole host distance table for consumers like the Coulomb potential.

Reimplemented from DistanceTable.

Definition at line 475 of file SoaDistanceTableAAOMPTarget.h.

References DistanceTable::modes_, DistanceTable::mw_evaluate(), qmcplusplus::NEED_FULL_TABLE_ON_HOST_AFTER_DONEPBYP, and qmcplusplus::NEED_TEMP_DATA_ON_HOST.

   {
     // if the distance table is not updated by mw_move during p-by-p, needs to recompute the whole table
     // before being used by Hamiltonian if requested
     if (!(modes_ & DTModes::NEED_TEMP_DATA_ON_HOST) && (modes_ & DTModes::NEED_FULL_TABLE_ON_HOST_AFTER_DONEPBYP))
       mw_evaluate(dt_list, p_list);
   }

◆ mw_move()

void mw_move	(	const RefVectorWithLeader< DistanceTable > &	dt_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		const std::vector< PosType > &	rnew_list,
		const IndexType	iat,
		bool	prepare_old = `true`
	)		const

inlineoverridevirtual

evaluate the temporary pair relations when a move is proposed this implementation is asynchronous and the synchronization is managed at ParticleSet.

Transferring results to host depends on DTModes::NEED_TEMP_DATA_ON_HOST. If the temporary pair distance are consumed on the device directly, the device to host data transfer can be skipped as an optimization.

Reimplemented from DistanceTable.

Definition at line 288 of file SoaDistanceTableAAOMPTarget.h.

References RefVectorWithLeader< T >::getCastedElement(), RefVectorWithLeader< T >::getCastedLeader(), RefVectorWithLeader< T >::getLeader(), omptarget::min(), DistanceTable::modes_, SoaDistanceTableAAOMPTarget< T, D, SC >::move_timer_, qmcplusplus::NEED_TEMP_DATA_ON_HOST, DistanceTable::num_targets_, SoaDistanceTableAAOMPTarget< T, D, SC >::num_targets_padded_, SoaDistanceTableAAOMPTarget< T, D, SC >::offload_timer_, and SoaDistanceTableAAOMPTarget< T, D, SC >::old_prepared_elec_id_.

   {
     assert(this == &dt_list.getLeader());
     auto& dt_leader            = dt_list.getCastedLeader<SoaDistanceTableAAOMPTarget>();
     DTAAMultiWalkerMem& mw_mem = dt_leader.mw_mem_handle_;
     auto& pset_leader          = p_list.getLeader();
 
     ScopedTimer local_timer(move_timer_);
     const size_t nw          = dt_list.size();
     const size_t stride_size = num_targets_padded_ * (D + 1);
 
     auto& mw_new_old_dist_displ = mw_mem.mw_new_old_dist_displ;
 
     for (int iw = 0; iw < nw; iw++)
     {
       auto& dt = dt_list.getCastedElement<SoaDistanceTableAAOMPTarget>(iw);
 #if !defined(NDEBUG)
       dt.old_prepared_elec_id_ = prepare_old ? iat : -1;
 #endif
       auto& coordinates_soa = static_cast<const RealSpacePositionsOMPTarget&>(p_list[iw].getCoordinates());
     }
 
     const int ChunkSizePerTeam = 512;
     const size_t num_teams     = (num_targets_ + ChunkSizePerTeam - 1) / ChunkSizePerTeam;
 
     auto& coordinates_leader = static_cast<const RealSpacePositionsOMPTarget&>(pset_leader.getCoordinates());
 
     const auto num_sources_local = num_targets_;
     const auto num_padded        = num_targets_padded_;
     auto* rsoa_dev_list_ptr      = coordinates_leader.getMultiWalkerRSoADevicePtrs().data();
     auto* r_dr_ptr               = mw_new_old_dist_displ.data();
     auto* new_pos_ptr            = coordinates_leader.getFusedNewPosBuffer().data();
     const size_t new_pos_stride  = coordinates_leader.getFusedNewPosBuffer().capacity();
 
     {
       ScopedTimer offload(offload_timer_);
       PRAGMA_OFFLOAD("omp target teams distribute collapse(2) num_teams(nw * num_teams) \
                           depend(out: r_dr_ptr[:mw_new_old_dist_displ.size()])")
       for (int iw = 0; iw < nw; ++iw)
         for (int team_id = 0; team_id < num_teams; team_id++)
         {
           auto* source_pos_ptr = rsoa_dev_list_ptr[iw];
           const size_t first   = ChunkSizePerTeam * team_id;
           const size_t last    = omptarget::min(first + ChunkSizePerTeam, num_sources_local);
 
           { // temp
             auto* r_iw_ptr  = r_dr_ptr + iw * stride_size;
             auto* dr_iw_ptr = r_dr_ptr + iw * stride_size + num_padded;
 
             T pos[D];
             for (int idim = 0; idim < D; idim++)
               pos[idim] = new_pos_ptr[idim * new_pos_stride + iw];
 
             PRAGMA_OFFLOAD("omp parallel for")
             for (int iel = first; iel < last; iel++)
               DTD_BConds<T, D, SC>::computeDistancesOffload(pos, source_pos_ptr, num_padded, r_iw_ptr, dr_iw_ptr,
                                                             num_padded, iel, iat);
           }
 
           if (prepare_old)
           { // old
             auto* r_iw_ptr  = r_dr_ptr + (iw + nw) * stride_size;
             auto* dr_iw_ptr = r_dr_ptr + (iw + nw) * stride_size + num_padded;
 
             T pos[D];
             for (int idim = 0; idim < D; idim++)
               pos[idim] = source_pos_ptr[idim * num_padded + iat];
 
             PRAGMA_OFFLOAD("omp parallel for")
             for (int iel = first; iel < last; iel++)
               DTD_BConds<T, D, SC>::computeDistancesOffload(pos, source_pos_ptr, num_padded, r_iw_ptr, dr_iw_ptr,
                                                             num_padded, iel, iat);
             r_iw_ptr[iat] = std::numeric_limits<T>::max(); //assign a big number
           }
         }
     }
 
     if (modes_ & DTModes::NEED_TEMP_DATA_ON_HOST)
     {
       PRAGMA_OFFLOAD("omp target update nowait depend(inout: r_dr_ptr[:mw_new_old_dist_displ.size()]) \
                       from(r_dr_ptr[:mw_new_old_dist_displ.size()])")
     }
   }

◆ mw_updatePartial()

void mw_updatePartial	(	const RefVectorWithLeader< DistanceTable > &	dt_list,
		IndexType	jat,
		const std::vector< bool > &	from_temp
	)

inlineoverridevirtual

walker batched version of updatePartial.

If not DTModes::NEED_TEMP_DATA_ON_HOST, host data is not up-to-date and host distance table will not be updated.

Reimplemented from DistanceTable.

Definition at line 463 of file SoaDistanceTableAAOMPTarget.h.

References DistanceTable::modes_, qmcplusplus::NEED_TEMP_DATA_ON_HOST, and SoaDistanceTableAAOMPTarget< T, D, SC >::updatePartial().

   {
     // if temp data on host is not updated by mw_move during p-by-p moves, there is no need to update distance table
     if (!(modes_ & DTModes::NEED_TEMP_DATA_ON_HOST))
       return;
 
     for (int iw = 0; iw < dt_list.size(); iw++)
       dt_list[iw].updatePartial(jat, from_temp[iw]);
   }

◆ releaseResource()

void releaseResource	(	ResourceCollection &	collection,
		const RefVectorWithLeader< DistanceTable > &	dt_list
	)		const

inlineoverridevirtual

return a shared resource to a collection

Reimplemented from DistanceTable.

Definition at line 158 of file SoaDistanceTableAAOMPTarget.h.

References Vector< T, Alloc >::free(), RefVectorWithLeader< T >::getCastedElement(), RefVectorWithLeader< T >::getCastedLeader(), SoaDistanceTableAAOMPTarget< T, D, SC >::mw_mem_handle_, ResourceCollection::takebackResource(), and DistanceTableAA::temp_r_.

   {
     collection.takebackResource(dt_list.getCastedLeader<SoaDistanceTableAAOMPTarget>().mw_mem_handle_);
     const size_t nw = dt_list.size();
     for (int iw = 0; iw < nw; iw++)
     {
       auto& dt = dt_list.getCastedElement<SoaDistanceTableAAOMPTarget>(iw);
       dt.temp_r_.free();
       dt.temp_dr_.free();
       dt.old_r_.free();
       dt.old_dr_.free();
     }
   }

◆ resize()

void resize ( )

inline

Definition at line 98 of file SoaDistanceTableAAOMPTarget.h.

References SoaDistanceTableAAOMPTarget< T, D, SC >::compute_size(), DistanceTableAA::displacements_, DistanceTableAA::distances_, SoaDistanceTableAAOMPTarget< T, D, SC >::memory_pool_, DistanceTable::num_targets_, SoaDistanceTableAAOMPTarget< T, D, SC >::old_dr_mem_, SoaDistanceTableAAOMPTarget< T, D, SC >::old_r_mem_, VectorSoaContainer< T, D, Alloc >::resize(), Vector< T, Alloc >::resize(), SoaDistanceTableAAOMPTarget< T, D, SC >::temp_dr_mem_, and SoaDistanceTableAAOMPTarget< T, D, SC >::temp_r_mem_.

Referenced by SoaDistanceTableAAOMPTarget< T, D, SC >::SoaDistanceTableAAOMPTarget().

   {
     // initialize memory containers and views
     const size_t total_size = compute_size(num_targets_);
     memory_pool_.resize(total_size * (1 + D));
     distances_.resize(num_targets_);
     displacements_.resize(num_targets_);
     for (int i = 0; i < num_targets_; ++i)
     {
       distances_[i].attachReference(memory_pool_.data() + compute_size(i), i);
       displacements_[i].attachReference(i, total_size, memory_pool_.data() + total_size + compute_size(i));
     }
 
     old_r_mem_.resize(num_targets_);
     old_dr_mem_.resize(num_targets_);
     temp_r_mem_.resize(num_targets_);
     temp_dr_mem_.resize(num_targets_);
   }

◆ update()

void update ( IndexType iat )

inlineoverridevirtual

After accepting the iat-th particle, update the iat-th row of distances_ and displacements_.

Upper triangle is not needed in the later computation and thus not updated

Implements DistanceTable.

Definition at line 420 of file SoaDistanceTableAAOMPTarget.h.

References qmcplusplus::syclBLAS::copy_n(), Vector< T, Alloc >::data(), VectorSoaContainer< T, D, Alloc >::data(), DistanceTableAA::displacements_, DistanceTableAA::distances_, DistanceTable::num_targets_, Vector< T, Alloc >::size(), DistanceTableAA::temp_dr_, DistanceTableAA::temp_r_, and SoaDistanceTableAAOMPTarget< T, D, SC >::update_timer_.

   {
     ScopedTimer local_timer(update_timer_);
     //update [0, iat) columns
     const int nupdate = iat;
     //copy row
     assert(nupdate <= temp_r_.size());
     std::copy_n(temp_r_.data(), nupdate, distances_[iat].data());
     for (int idim = 0; idim < D; ++idim)
       std::copy_n(temp_dr_.data(idim), nupdate, displacements_[iat].data(idim));
     //copy column
     for (size_t i = iat + 1; i < num_targets_; ++i)
     {
       distances_[i][iat]     = temp_r_[i];
       displacements_[i](iat) = -temp_dr_[i];
     }
   }

◆ updatePartial()

void updatePartial	(	IndexType	jat,
		bool	from_temp
	)

inlineoverridevirtual

fill partially the distance table by the pair relations from the temporary or old particle position.

Used in forward mode when a move is reject

Parameters

iat	the particle with an accepted move
from_temp	if true, copy from temp. if false, copy from old

Reimplemented from DistanceTable.

Definition at line 438 of file SoaDistanceTableAAOMPTarget.h.

References qmcplusplus::syclBLAS::copy_n(), Vector< T, Alloc >::data(), VectorSoaContainer< T, D, Alloc >::data(), DistanceTableAA::displacements_, DistanceTableAA::distances_, DistanceTableAA::old_dr_, SoaDistanceTableAAOMPTarget< T, D, SC >::old_prepared_elec_id_, DistanceTableAA::old_r_, Vector< T, Alloc >::size(), DistanceTableAA::temp_dr_, DistanceTableAA::temp_r_, and SoaDistanceTableAAOMPTarget< T, D, SC >::update_timer_.

Referenced by SoaDistanceTableAAOMPTarget< T, D, SC >::mw_updatePartial().

   {
     ScopedTimer local_timer(update_timer_);
 
     //update [0, jat)
     const int nupdate = jat;
     if (from_temp)
     {
       //copy row
       assert(nupdate <= temp_r_.size());
       std::copy_n(temp_r_.data(), nupdate, distances_[jat].data());
       for (int idim = 0; idim < D; ++idim)
         std::copy_n(temp_dr_.data(idim), nupdate, displacements_[jat].data(idim));
     }
     else
     {
       assert(old_prepared_elec_id_ == jat);
       //copy row
       assert(nupdate <= old_r_.size());
       std::copy_n(old_r_.data(), nupdate, distances_[jat].data());
       for (int idim = 0; idim < D; ++idim)
         std::copy_n(old_dr_.data(idim), nupdate, displacements_[jat].data(idim));
     }
   }