static void free_work(struct pme_solve_work_t *work)
{
sfree(work->mhx);
sfree(work->mhy);
sfree(work->mhz);
sfree(work->m2);
sfree_aligned(work->denom);
sfree_aligned(work->tmp1);
sfree_aligned(work->tmp2);
sfree_aligned(work->eterm);
sfree(work->m2inv);
}
/*! \brief Frees memory allocated with ocl_pmalloc.
*
* \param[in] h_ptr Buffer allocated with ocl_pmalloc that needs to be freed.
*/
void ocl_pfree(void *h_ptr)
{
if (h_ptr)
{
sfree_aligned(h_ptr);
}
return;
}
//! Construct a reduction mask for which parts (blocks) of the force array are touched on which thread task
static void
calc_bonded_reduction_mask(int natoms,
f_thread_t *f_thread,
const t_idef *idef,
int thread, int nthread)
{
static_assert(BITMASK_SIZE == GMX_OPENMP_MAX_THREADS, "For the error message below we assume these two are equal.");
if (nthread > BITMASK_SIZE)
{
#pragma omp master
gmx_fatal(FARGS, "You are using %d OpenMP threads, which is larger than GMX_OPENMP_MAX_THREADS (%d). Decrease the number of OpenMP threads or rebuild GROMACS with a larger value for GMX_OPENMP_MAX_THREADS.",
nthread, GMX_OPENMP_MAX_THREADS);
#pragma omp barrier
}
GMX_ASSERT(nthread <= BITMASK_SIZE, "We need at least nthread bits in the mask");
int nblock = (natoms + reduction_block_size - 1) >> reduction_block_bits;
if (nblock > f_thread->block_nalloc)
{
f_thread->block_nalloc = over_alloc_large(nblock);
srenew(f_thread->mask, f_thread->block_nalloc);
srenew(f_thread->block_index, f_thread->block_nalloc);
sfree_aligned(f_thread->f);
snew_aligned(f_thread->f, f_thread->block_nalloc*reduction_block_size, 128);
}
gmx_bitmask_t *mask = f_thread->mask;
for (int b = 0; b < nblock; b++)
{
bitmask_clear(&mask[b]);
}
for (int ftype = 0; ftype < F_NRE; ftype++)
{
if (ftype_is_bonded_potential(ftype))
{
int nb = idef->il[ftype].nr;
if (nb > 0)
{
int nat1 = interaction_function[ftype].nratoms + 1;
int nb0 = idef->il_thread_division[ftype*(nthread + 1) + thread];
int nb1 = idef->il_thread_division[ftype*(nthread + 1) + thread + 1];
for (int i = nb0; i < nb1; i += nat1)
{
for (int a = 1; a < nat1; a++)
{
bitmask_set_bit(&mask[idef->il[ftype].iatoms[i+a] >> reduction_block_bits], thread);
}
}
}
}
}
static void realloc_work(struct pme_solve_work_t *work, int nkx)
{
if (nkx > work->nalloc)
{
int simd_width, i;
work->nalloc = nkx;
srenew(work->mhx, work->nalloc);
srenew(work->mhy, work->nalloc);
srenew(work->mhz, work->nalloc);
srenew(work->m2, work->nalloc);
/* Allocate an aligned pointer for SIMD operations, including extra
* elements at the end for padding.
*/
#ifdef PME_SIMD_SOLVE
simd_width = GMX_SIMD_REAL_WIDTH;
#else
/* We can use any alignment, apart from 0, so we use 4 */
simd_width = 4;
#endif
sfree_aligned(work->denom);
sfree_aligned(work->tmp1);
sfree_aligned(work->tmp2);
sfree_aligned(work->eterm);
snew_aligned(work->denom, work->nalloc+simd_width, simd_width*sizeof(real));
snew_aligned(work->tmp1, work->nalloc+simd_width, simd_width*sizeof(real));
snew_aligned(work->tmp2, work->nalloc+simd_width, simd_width*sizeof(real));
snew_aligned(work->eterm, work->nalloc+simd_width, simd_width*sizeof(real));
srenew(work->m2inv, work->nalloc);
/* Init all allocated elements of denom to 1 to avoid 1/0 exceptions
* of simd padded elements.
*/
for (i = 0; i < work->nalloc+simd_width; i++)
{
work->denom[i] = 1;
}
}
}
void reuse_pmegrids(const pmegrids_t *oldgrid, pmegrids_t *newgrid)
{
int d, t;
for (d = 0; d < DIM; d++)
{
if (newgrid->grid.n[d] > oldgrid->grid.n[d])
{
return;
}
}
sfree_aligned(newgrid->grid.grid);
newgrid->grid.grid = oldgrid->grid.grid;
if (newgrid->grid_th != NULL && newgrid->nthread == oldgrid->nthread)
{
sfree_aligned(newgrid->grid_all);
for (t = 0; t < newgrid->nthread; t++)
{
newgrid->grid_th[t].grid = oldgrid->grid_th[t].grid;
}
}
}
static void realloc_splinevec(splinevec th, real **ptr_z, int nalloc)
{
const int padding = 4;
int i;
srenew(th[XX], nalloc);
srenew(th[YY], nalloc);
/* In z we add padding, this is only required for the aligned SIMD code */
sfree_aligned(*ptr_z);
snew_aligned(*ptr_z, nalloc+2*padding, SIMD4_ALIGNMENT);
th[ZZ] = *ptr_z + padding;
for (i = 0; i < padding; i++)
{
(*ptr_z)[ i] = 0;
(*ptr_z)[padding+nalloc+i] = 0;
}
}
/* Free function for memory allocated with nbnxn_alloc_aligned */
void nbnxn_free_aligned(void *ptr)
{
sfree_aligned(ptr);
}
