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); }