A derived classe from DistacneTableData, specialized for AB using a transposed form. More...

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

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

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

Public Member Functions
	SoaDistanceTableABOMPTarget (const ParticleSet &source, ParticleSet &target)

	SoaDistanceTableABOMPTarget ()=delete

	SoaDistanceTableABOMPTarget (const SoaDistanceTableABOMPTarget &)=delete

	~SoaDistanceTableABOMPTarget ()

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...

const T *	getMultiWalkerDataPtr () const override
	return multi-walker full (all pairs) distance table data pointer More...

size_t	getPerTargetPctlStrideSize () const override
	return stride of per target pctl data. full table data = stride * num of target particles More...

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

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

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

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

void	update (IndexType iat) override
	update the stripe for jat-th particle More...

int	get_first_neighbor (IndexType iat, RealType &r, PosType &dr, bool newpos) 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 DistanceTableAB
	DistanceTableAB (const ParticleSet &source, 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...

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_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
	walker batched version of move. More...

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

virtual void	mw_updatePartial (const RefVectorWithLeader< DistanceTable > &dt_list, IndexType jat, const std::vector< bool > &from_temp)
	walker batched version of updatePartial. 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 void	mw_finalizePbyP (const RefVectorWithLeader< DistanceTable > &dt_list, const RefVectorWithLeader< ParticleSet > &p_list) const
	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...

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)

Private Types
template<typename DT >
using	OffloadPinnedVector = Vector< DT, OMPallocator< DT, PinnedAlignedAllocator< DT > >>

Private Member Functions
void	resize ()

Static Private Member Functions
static void	associateResource (const RefVectorWithLeader< DistanceTable > &dt_list)

Private Attributes
OffloadPinnedVector< RealType >	r_dr_memorypool_
	accelerator output buffer for r and dr More...

OffloadPinnedVector< T >	target_pos
	accelerator input array for a list of target particle positions, num_targets_ x D More...

ResourceHandle< DTABMultiWalkerMem >	mw_mem_handle_

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...

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 DistanceTableAB
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 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 More...

DistRow	temp_r_
	temp_r More...

DisplRow	temp_dr_
	temp_dr 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>
class qmcplusplus::SoaDistanceTableABOMPTarget< T, D, SC >

A derived classe from DistacneTableData, specialized for AB using a transposed form.

Definition at line 31 of file SoaDistanceTableABOMPTarget.h.

Member Typedef Documentation

◆ OffloadPinnedVector

using OffloadPinnedVector = Vector<DT, OMPallocator<DT, PinnedAlignedAllocator<DT> >>

private

Definition at line 35 of file SoaDistanceTableABOMPTarget.h.

Constructor & Destructor Documentation

◆ SoaDistanceTableABOMPTarget() [1/3]

SoaDistanceTableABOMPTarget	(	const ParticleSet &	source,
		ParticleSet &	target
	)

inline

Definition at line 121 of file SoaDistanceTableABOMPTarget.h.

References ParticleSet::getCoordinates(), DistanceTable::num_sources_, VectorSoaContainer< T, D, Alloc >::resize(), Vector< T, Alloc >::resize(), DistanceTableAB::temp_dr_, and DistanceTableAB::temp_r_.

       : DTD_BConds<T, D, SC>(source.getLattice()),
         DistanceTableAB(source, target, DTModes::ALL_OFF),
         offload_timer_(createGlobalTimer(std::string("DTABOMPTarget::offload_") + name_, timer_level_fine)),
         evaluate_timer_(createGlobalTimer(std::string("DTABOMPTarget::evaluate_") + name_, timer_level_fine)),
         move_timer_(createGlobalTimer(std::string("DTABOMPTarget::move_") + name_, timer_level_fine)),
         update_timer_(createGlobalTimer(std::string("DTABOMPTarget::update_") + name_, timer_level_fine))
 
   {
     auto* coordinates_soa = dynamic_cast<const RealSpacePositionsOMPTarget*>(&source.getCoordinates());
     if (!coordinates_soa)
       throw std::runtime_error("Source particle set doesn't have OpenMP offload. Contact developers!");
     PRAGMA_OFFLOAD("omp target enter data map(to : this[:1])")
 
     // The padding of temp_r_ and temp_dr_ is necessary for the memory copy in the update function
     // temp_r_ is padded explicitly while temp_dr_ is padded internally
     const int num_padded = getAlignedSize<T>(num_sources_);
     temp_r_.resize(num_padded);
     temp_dr_.resize(num_sources_);
   }

◆ SoaDistanceTableABOMPTarget() [2/3]

SoaDistanceTableABOMPTarget ( )

delete

◆ SoaDistanceTableABOMPTarget() [3/3]

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

delete

◆ ~SoaDistanceTableABOMPTarget()

~SoaDistanceTableABOMPTarget ( )

inline

Definition at line 145 of file SoaDistanceTableABOMPTarget.h.

145 { 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 152 of file SoaDistanceTableABOMPTarget.h.

References SoaDistanceTableABOMPTarget< T, D, SC >::associateResource(), RefVectorWithLeader< T >::getCastedLeader(), ResourceCollection::lendResource(), and SoaDistanceTableABOMPTarget< T, D, SC >::mw_mem_handle_.

   {
     auto& dt_leader          = dt_list.getCastedLeader<SoaDistanceTableABOMPTarget>();
     dt_leader.mw_mem_handle_ = collection.lendResource<DTABMultiWalkerMem>();
     associateResource(dt_list);
   }

◆ associateResource()

static void associateResource ( const RefVectorWithLeader< DistanceTable > & dt_list )

inlinestaticprivate

Definition at line 81 of file SoaDistanceTableABOMPTarget.h.

References RefVectorWithLeader< T >::getCastedElement(), RefVectorWithLeader< T >::getCastedLeader(), and DistanceTable::targets().

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

   {
     auto& dt_leader = dt_list.getCastedLeader<SoaDistanceTableABOMPTarget>();
 
     // initialize memory containers and views
     size_t count_targets = 0;
     for (size_t iw = 0; iw < dt_list.size(); iw++)
     {
       auto& dt = dt_list.getCastedElement<SoaDistanceTableABOMPTarget>(iw);
       count_targets += dt.targets();
       dt.r_dr_memorypool_.free();
     }
 
     const size_t num_sources   = dt_leader.num_sources_;
     const size_t num_padded    = getAlignedSize<T>(dt_leader.num_sources_);
     const size_t stride_size   = num_padded * (D + 1);
     const size_t total_targets = count_targets;
     auto& mw_r_dr              = dt_leader.mw_mem_handle_.getResource().mw_r_dr;
     mw_r_dr.resize(total_targets * stride_size);
 
     count_targets = 0;
     for (size_t iw = 0; iw < dt_list.size(); iw++)
     {
       auto& dt = dt_list.getCastedElement<SoaDistanceTableABOMPTarget>(iw);
       assert(num_sources == dt.num_sources_);
 
       dt.distances_.resize(dt.targets());
       dt.displacements_.resize(dt.targets());
 
       for (int i = 0; i < dt.targets(); ++i)
       {
         dt.distances_[i].attachReference(mw_r_dr.data() + (i + count_targets) * stride_size, num_sources);
         dt.displacements_[i].attachReference(num_sources, num_padded,
                                              mw_r_dr.data() + (i + count_targets) * stride_size + num_padded);
       }
       count_targets += dt.targets();
     }
   }

◆ createResource()

void createResource ( ResourceCollection & collection ) const

inlineoverridevirtual

initialize a shared resource and hand it to a collection

Reimplemented from DistanceTable.

Definition at line 147 of file SoaDistanceTableABOMPTarget.h.

References ResourceCollection::addResource().

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

◆ evaluate()

void evaluate ( ParticleSet & P )

inlineoverridevirtual

evaluate the full table

Implements DistanceTable.

Definition at line 175 of file SoaDistanceTableABOMPTarget.h.

References VectorSoaContainer< T, D, Alloc >::data(), DistanceTableAB::displacements_, DistanceTableAB::distances_, SoaDistanceTableABOMPTarget< T, D, SC >::evaluate_timer_, DynamicCoordinates::getAllParticlePos(), ParticleSet::getCoordinates(), SoaDistanceTableABOMPTarget< T, D, SC >::getPerTargetPctlStrideSize(), omptarget::min(), DistanceTable::num_sources_, DistanceTable::num_targets_, SoaDistanceTableABOMPTarget< T, D, SC >::offload_timer_, DistanceTable::origin_, ParticleSet::R, SoaDistanceTableABOMPTarget< T, D, SC >::resize(), and SoaDistanceTableABOMPTarget< T, D, SC >::target_pos.

   {
     resize();
 
     ScopedTimer local_timer(evaluate_timer_);
     // be aware of the sign of Displacement
     const int num_targets_local = num_targets_;
     const int num_sources_local = num_sources_;
     const int num_padded        = getAlignedSize<T>(num_sources_);
 
     target_pos.resize(num_targets_ * D);
     for (size_t iat = 0; iat < num_targets_; iat++)
       for (size_t idim = 0; idim < D; idim++)
         target_pos[iat * D + idim] = P.R[iat][idim];
 
     auto* target_pos_ptr = target_pos.data();
     auto* source_pos_ptr = origin_.getCoordinates().getAllParticlePos().data();
     auto* r_dr_ptr       = distances_[0].data();
     assert(distances_[0].data() + num_padded == displacements_[0].data());
 
     // To maximize thread usage, the loop over electrons is chunked. Each chunk is sent to an OpenMP offload thread team.
     const int ChunkSizePerTeam = 512;
     const size_t num_teams     = (num_sources_ + ChunkSizePerTeam - 1) / ChunkSizePerTeam;
     const size_t stride_size   = getPerTargetPctlStrideSize();
 
     {
       ScopedTimer offload(offload_timer_);
       PRAGMA_OFFLOAD("omp target teams distribute collapse(2) num_teams(num_targets_*num_teams) \
                         map(to: source_pos_ptr[:num_padded*D]) \
                         map(always, to: target_pos_ptr[:num_targets_*D]) \
                         map(always, from: r_dr_ptr[:num_targets_*stride_size])")
       for (int iat = 0; iat < num_targets_local; ++iat)
         for (int team_id = 0; team_id < num_teams; team_id++)
         {
           const int first = ChunkSizePerTeam * team_id;
           const int last  = omptarget::min(first + ChunkSizePerTeam, num_sources_local);
 
           T pos[D];
           for (int idim = 0; idim < D; idim++)
             pos[idim] = target_pos_ptr[iat * D + idim];
 
           auto* r_iat_ptr  = r_dr_ptr + iat * stride_size;
           auto* dr_iat_ptr = r_iat_ptr + num_padded;
 
           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_iat_ptr, dr_iat_ptr,
                                                           num_padded, iel);
         }
     }
   }

◆ get_first_neighbor()

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

inlineoverride

Definition at line 369 of file SoaDistanceTableABOMPTarget.h.

References DistanceTableAB::displacements_, DistanceTableAB::distances_, DistanceTable::num_sources_, DistanceTableAB::temp_dr_, and DistanceTableAB::temp_r_.

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

◆ getMultiWalkerDataPtr()

const T* getMultiWalkerDataPtr ( ) const

inlineoverridevirtual

return multi-walker full (all pairs) distance table data pointer

Reimplemented from DistanceTableAB.

Definition at line 170 of file SoaDistanceTableABOMPTarget.h.

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

170 { return mw_mem_handle_.getResource().mw_r_dr.data(); }

qmcplusplus::SoaDistanceTableABOMPTarget::mw_mem_handle_

ResourceHandle< DTABMultiWalkerMem > mw_mem_handle_

Definition: SoaDistanceTableABOMPTarget.h:57

◆ getPerTargetPctlStrideSize()

size_t getPerTargetPctlStrideSize ( ) const

inlineoverridevirtual

return stride of per target pctl data. full table data = stride * num of target particles

Reimplemented from DistanceTableAB.

Definition at line 172 of file SoaDistanceTableABOMPTarget.h.

References DistanceTable::num_sources_.

Referenced by SoaDistanceTableABOMPTarget< T, D, SC >::evaluate(), SoaDistanceTableABOMPTarget< T, D, SC >::mw_evaluate(), and SoaDistanceTableABOMPTarget< T, D, SC >::resize().

172 { return getAlignedSize<T>(num_sources_) * (D + 1); }

qmcplusplus::DistanceTable::num_sources_

const size_t num_sources_

Definition: DistanceTable.h:53

◆ 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 348 of file SoaDistanceTableABOMPTarget.h.

References Vector< T, Alloc >::data(), DistanceTableAB::displacements_, DistanceTableAB::distances_, DynamicCoordinates::getAllParticlePos(), ParticleSet::getCoordinates(), DistanceTable::modes_, SoaDistanceTableABOMPTarget< T, D, SC >::move_timer_, qmcplusplus::NEED_FULL_TABLE_ANYTIME, DistanceTable::num_sources_, DistanceTable::origin_, ParticleSet::R, DistanceTableAB::temp_dr_, and DistanceTableAB::temp_r_.

   {
     ScopedTimer local_timer(move_timer_);
     DTD_BConds<T, D, SC>::computeDistances(rnew, origin_.getCoordinates().getAllParticlePos(), temp_r_.data(), temp_dr_,
                                            0, num_sources_);
     // If the full table is not ready all the time, overwrite the current value.
     // If this step is missing, DT values can be undefined in case a move is rejected.
     if (!(modes_ & DTModes::NEED_FULL_TABLE_ANYTIME) && prepare_old)
       DTD_BConds<T, D, SC>::computeDistances(P.R[iat], origin_.getCoordinates().getAllParticlePos(),
                                              distances_[iat].data(), displacements_[iat], 0, num_sources_);
   }

◆ mw_evaluate()

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

inlineoverridevirtual

Reimplemented from DistanceTable.

Definition at line 227 of file SoaDistanceTableABOMPTarget.h.

References SoaDistanceTableABOMPTarget< T, D, SC >::evaluate_timer_, RefVectorWithLeader< T >::getCastedElement(), RefVectorWithLeader< T >::getCastedLeader(), RefVectorWithLeader< T >::getLeader(), SoaDistanceTableABOMPTarget< T, D, SC >::getPerTargetPctlStrideSize(), omptarget::min(), DistanceTable::modes_, qmcplusplus::MW_EVALUATE_RESULT_NO_TRANSFER_TO_HOST, SoaDistanceTableABOMPTarget< T, D, SC >::DTABMultiWalkerMem::mw_r_dr, DistanceTable::num_sources_, SoaDistanceTableABOMPTarget< T, D, SC >::DTABMultiWalkerMem::offload_input, and qmcplusplus::pset.

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

   {
     assert(this == &dt_list.getLeader());
     auto& dt_leader = dt_list.getCastedLeader<SoaDistanceTableABOMPTarget>();
 
     ScopedTimer local_timer(evaluate_timer_);
 
     const size_t nw            = dt_list.size();
     DTABMultiWalkerMem& mw_mem = dt_leader.mw_mem_handle_;
     auto& mw_r_dr              = mw_mem.mw_r_dr;
 
     size_t count_targets = 0;
     for (ParticleSet& p : p_list)
       count_targets += p.getTotalNum();
     const size_t total_targets = count_targets;
 
     const int num_padded = getAlignedSize<T>(num_sources_);
 
 #ifndef NDEBUG
     const int stride_size = getPerTargetPctlStrideSize();
     count_targets         = 0;
     for (size_t iw = 0; iw < dt_list.size(); iw++)
     {
       auto& dt = dt_list.getCastedElement<SoaDistanceTableABOMPTarget>(iw);
 
       for (int i = 0; i < dt.targets(); ++i)
       {
         assert(dt.distances_[i].data() == mw_r_dr.data() + (i + count_targets) * stride_size);
         assert(dt.displacements_[i].data() == mw_r_dr.data() + (i + count_targets) * stride_size + num_padded);
       }
       count_targets += dt.targets();
     }
 #endif
 
     // This is horrible optimization putting different data types in a single buffer but allows a single H2D transfer
     const size_t realtype_size = sizeof(RealType);
     const size_t int_size      = sizeof(int);
     const size_t ptr_size      = sizeof(RealType*);
     auto& offload_input        = mw_mem.offload_input;
     offload_input.resize(total_targets * D * realtype_size + total_targets * int_size + nw * ptr_size);
     auto source_ptrs      = reinterpret_cast<RealType**>(offload_input.data());
     auto target_positions = reinterpret_cast<RealType*>(offload_input.data() + ptr_size * nw);
     auto walker_id_ptr =
         reinterpret_cast<int*>(offload_input.data() + ptr_size * nw + total_targets * D * realtype_size);
 
     count_targets = 0;
     for (size_t iw = 0; iw < nw; iw++)
     {
       auto& dt = dt_list.getCastedElement<SoaDistanceTableABOMPTarget>(iw);
       ParticleSet& pset(p_list[iw]);
 
       assert(dt.targets() == pset.getTotalNum());
       assert(num_sources_ == dt.num_sources_);
 
       auto& RSoA_OMPTarget = static_cast<const RealSpacePositionsOMPTarget&>(dt.origin_.getCoordinates());
       source_ptrs[iw]      = const_cast<RealType*>(RSoA_OMPTarget.getDevicePtr());
 
       for (size_t iat = 0; iat < pset.getTotalNum(); ++iat, ++count_targets)
       {
         walker_id_ptr[count_targets] = iw;
         for (size_t idim = 0; idim < D; idim++)
           target_positions[count_targets * D + idim] = pset.R[iat][idim];
       }
     }
 
     // To maximize thread usage, the loop over electrons is chunked. Each chunk is sent to an OpenMP offload thread team.
     const int ChunkSizePerTeam = 512;
     const size_t num_teams     = (num_sources_ + ChunkSizePerTeam - 1) / ChunkSizePerTeam;
 
     auto* r_dr_ptr              = mw_r_dr.data();
     auto* input_ptr             = offload_input.data();
     const int num_sources_local = num_sources_;
 
     {
       ScopedTimer offload(dt_leader.offload_timer_);
       PRAGMA_OFFLOAD("omp target teams distribute collapse(2) num_teams(total_targets*num_teams) \
                           map(always, to: input_ptr[:offload_input.size()]) \
                           depend(out:r_dr_ptr[:mw_r_dr.size()])")
       for (int iat = 0; iat < total_targets; ++iat)
         for (int team_id = 0; team_id < num_teams; team_id++)
         {
           auto* target_pos_ptr = reinterpret_cast<RealType*>(input_ptr + ptr_size * nw);
           const int walker_id =
               reinterpret_cast<int*>(input_ptr + ptr_size * nw + total_targets * D * realtype_size)[iat];
           auto* source_pos_ptr = reinterpret_cast<RealType**>(input_ptr)[walker_id];
           auto* r_iat_ptr      = r_dr_ptr + iat * num_padded * (D + 1);
           auto* dr_iat_ptr     = r_dr_ptr + iat * num_padded * (D + 1) + num_padded;
 
           const int first = ChunkSizePerTeam * team_id;
           const int last  = omptarget::min(first + ChunkSizePerTeam, num_sources_local);
 
           T pos[D];
           for (int idim = 0; idim < D; idim++)
             pos[idim] = target_pos_ptr[iat * D + idim];
 
           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_iat_ptr, dr_iat_ptr,
                                                           num_padded, iel);
         }
 
       if (!(modes_ & DTModes::MW_EVALUATE_RESULT_NO_TRANSFER_TO_HOST))
       {
         PRAGMA_OFFLOAD(
             "omp target update from(r_dr_ptr[:mw_r_dr.size()]) depend(inout:r_dr_ptr[:mw_r_dr.size()]) nowait")
       }
       // wait for computing and (optional) transferring back to host.
       // It can potentially be moved to ParticleSet to fuse multiple similar taskwait
       PRAGMA_OFFLOAD("omp taskwait")
     }
   }

◆ mw_recompute()

void mw_recompute	(	const RefVectorWithLeader< DistanceTable > &	dt_list,
		const RefVectorWithLeader< ParticleSet > &	p_list,
		const std::vector< bool > &	recompute
	)		const

inlineoverridevirtual

recompute multi walker internal data, recompute

Parameters

dt_list	the distance table batch
p_list	the target particle set batch
recompute	if true, must recompute. Otherwise, implementation dependent.

Reimplemented from DistanceTable.

Definition at line 340 of file SoaDistanceTableABOMPTarget.h.

References SoaDistanceTableABOMPTarget< T, D, SC >::mw_evaluate().

   {
     mw_evaluate(dt_list, p_list);
   }

◆ 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 159 of file SoaDistanceTableABOMPTarget.h.

References DistanceTableAB::distances_, RefVectorWithLeader< T >::getCastedElement(), RefVectorWithLeader< T >::getCastedLeader(), SoaDistanceTableABOMPTarget< T, D, SC >::mw_mem_handle_, and ResourceCollection::takebackResource().

   {
     collection.takebackResource(dt_list.getCastedLeader<SoaDistanceTableABOMPTarget>().mw_mem_handle_);
     for (size_t iw = 0; iw < dt_list.size(); iw++)
     {
       auto& dt = dt_list.getCastedElement<SoaDistanceTableABOMPTarget>(iw);
       dt.distances_.clear();
       dt.displacements_.clear();
     }
   }

◆ resize()

void resize ( )

inlineprivate

Definition at line 59 of file SoaDistanceTableABOMPTarget.h.

References DistanceTableAB::displacements_, DistanceTableAB::distances_, SoaDistanceTableABOMPTarget< T, D, SC >::getPerTargetPctlStrideSize(), DistanceTable::num_sources_, DistanceTable::num_targets_, and SoaDistanceTableABOMPTarget< T, D, SC >::r_dr_memorypool_.

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

   {
     if (num_sources_ * num_targets_ == 0)
       return;
     if (distances_.size())
       return;
 
     // initialize memory containers and views
     const size_t num_padded  = getAlignedSize<T>(num_sources_);
     const size_t stride_size = getPerTargetPctlStrideSize();
     r_dr_memorypool_.resize(stride_size * num_targets_);
 
     distances_.resize(num_targets_);
     displacements_.resize(num_targets_);
     for (int i = 0; i < num_targets_; ++i)
     {
       distances_[i].attachReference(r_dr_memorypool_.data() + i * stride_size, num_sources_);
       displacements_[i].attachReference(num_sources_, num_padded,
                                         r_dr_memorypool_.data() + i * stride_size + num_padded);
     }
   }

◆ update()

void update ( IndexType iat )

inlineoverridevirtual

update the stripe for jat-th particle

Implements DistanceTable.

Definition at line 361 of file SoaDistanceTableABOMPTarget.h.

References qmcplusplus::syclBLAS::copy_n(), Vector< T, Alloc >::data(), VectorSoaContainer< T, D, Alloc >::data(), DistanceTableAB::displacements_, DistanceTableAB::distances_, DistanceTable::num_sources_, DistanceTableAB::temp_dr_, DistanceTableAB::temp_r_, and SoaDistanceTableABOMPTarget< T, D, SC >::update_timer_.

   {
     ScopedTimer local_timer(update_timer_);
     std::copy_n(temp_r_.data(), num_sources_, distances_[iat].data());
     for (int idim = 0; idim < D; ++idim)
       std::copy_n(temp_dr_.data(idim), num_sources_, displacements_[iat].data(idim));
   }