void gmx_init_intranode_counters(t_commrec *cr)
{
/* counters for PP+PME and PP-only processes on my physical node */
int nrank_intranode, rank_intranode;
int nrank_pp_intranode, rank_pp_intranode;
/* thread-MPI is not initialized when not running in parallel */
#if defined GMX_MPI && !defined GMX_THREAD_MPI
int nrank_world, rank_world;
int i, mynum, *num, *num_s, *num_pp, *num_pp_s;
MPI_Comm_size(MPI_COMM_WORLD, &nrank_world);
MPI_Comm_rank(MPI_COMM_WORLD, &rank_world);
/* Get the node number from the hostname to identify the nodes */
mynum = gmx_hostname_num();
/* We can't rely on MPI_IN_PLACE, so we need send and receive buffers */
snew(num, nrank_world);
snew(num_s, nrank_world);
snew(num_pp, nrank_world);
snew(num_pp_s, nrank_world);
num_s[rank_world] = mynum;
num_pp_s[rank_world] = (cr->duty & DUTY_PP) ? mynum : -1;
MPI_Allreduce(num_s, num, nrank_world, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
MPI_Allreduce(num_pp_s, num_pp, nrank_world, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
nrank_intranode = 0;
rank_intranode = 0;
nrank_pp_intranode = 0;
rank_pp_intranode = 0;
for (i = 0; i < nrank_world; i++)
{
if (num[i] == mynum)
{
nrank_intranode++;
if (i < rank_world)
{
rank_intranode++;
}
}
if ((cr->duty & DUTY_PP) && num_pp[i] == mynum)
{
nrank_pp_intranode++;
if (i < rank_world)
{
rank_pp_intranode++;
}
}
}
sfree(num);
sfree(num_s);
sfree(num_pp);
sfree(num_pp_s);
#else
/* Serial or thread-MPI code: we run within a single physical node */
nrank_intranode = cr->nnodes;
rank_intranode = cr->sim_nodeid;
nrank_pp_intranode = cr->nnodes - cr->npmenodes;
rank_pp_intranode = cr->nodeid;
#endif
if (debug)
{
char sbuf[STRLEN];
if (cr->duty & DUTY_PP && cr->duty & DUTY_PME)
{
sprintf(sbuf, "PP+PME");
}
else
{
sprintf(sbuf, "%s", cr->duty & DUTY_PP ? "PP" : "PME");
}
fprintf(debug, "On %3s node %d: nrank_intranode=%d, rank_intranode=%d, "
"nrank_pp_intranode=%d, rank_pp_intranode=%d\n",
sbuf, cr->sim_nodeid,
nrank_intranode, rank_intranode,
nrank_pp_intranode, rank_pp_intranode);
}
cr->nrank_intranode = nrank_intranode;
cr->rank_intranode = rank_intranode;
cr->nrank_pp_intranode = nrank_pp_intranode;
cr->rank_pp_intranode = rank_pp_intranode;
}
/* Set CPU affinity. Can be important for performance.
On some systems (e.g. Cray) CPU Affinity is set by default.
But default assigning doesn't work (well) with only some ranks
having threads. This causes very low performance.
External tools have cumbersome syntax for setting affinity
in the case that only some ranks have threads.
Thus it is important that GROMACS sets the affinity internally
if only PME is using threads.
*/
void
gmx_set_thread_affinity(FILE *fplog,
const t_commrec *cr,
gmx_hw_opt_t *hw_opt,
int nthreads_pme,
const gmx_hw_info_t *hwinfo,
const t_inputrec *inputrec)
{
int nth_affinity_set, thread_id_node, thread_id,
nthread_local, nthread_node, nthread_hw_max, nphyscore;
int offset;
const int *locality_order;
int rc;
if (hw_opt->thread_affinity == threadaffOFF)
{
/* Nothing to do */
return;
}
/* If the tMPI thread affinity setting is not supported encourage the user
* to report it as it's either a bug or an exotic platform which we might
* want to support. */
if (tMPI_Thread_setaffinity_support() != TMPI_SETAFFINITY_SUPPORT_YES)
{
/* we know Mac OS doesn't support setting thread affinity, so there's
no point in warning the user in that case. In any other case
the user might be able to do something about it. */
#ifndef __APPLE__
md_print_warn(NULL, fplog,
"Can not set thread affinities on the current platform. On NUMA systems this\n"
"can cause performance degradation. If you think your platform should support\n"
"setting affinities, contact the GROMACS developers.");
#endif /* __APPLE__ */
return;
}
/* threads on this MPI process or TMPI thread */
if (cr->duty & DUTY_PP)
{
nthread_local = gmx_omp_nthreads_get(emntNonbonded);
}
else
{
nthread_local = gmx_omp_nthreads_get(emntPME);
}
/* map the current process to cores */
thread_id_node = 0;
nthread_node = nthread_local;
#ifdef GMX_MPI
if (PAR(cr) || MULTISIM(cr))
{
/* We need to determine a scan of the thread counts in this
* compute node.
*/
MPI_Comm comm_intra;
MPI_Comm_split(MPI_COMM_WORLD, gmx_hostname_num(), cr->rank_intranode,
&comm_intra);
MPI_Scan(&nthread_local, &thread_id_node, 1, MPI_INT, MPI_SUM, comm_intra);
/* MPI_Scan is inclusive, but here we need exclusive */
thread_id_node -= nthread_local;
/* Get the total number of threads on this physical node */
MPI_Allreduce(&nthread_local, &nthread_node, 1, MPI_INT, MPI_SUM, comm_intra);
MPI_Comm_free(&comm_intra);
}
#endif
if (hw_opt->thread_affinity == threadaffAUTO &&
nthread_node != hwinfo->nthreads_hw_avail)
{
if (nthread_node > 1 && nthread_node < hwinfo->nthreads_hw_avail)
{
md_print_warn(cr, fplog,
"NOTE: The number of threads is not equal to the number of (logical) cores\n"
" and the -pin option is set to auto: will not pin thread to cores.\n"
" This can lead to significant performance degradation.\n"
" Consider using -pin on (and -pinoffset in case you run multiple jobs).\n");
}
return;
}
offset = 0;
if (hw_opt->core_pinning_offset != 0)
{
offset = hw_opt->core_pinning_offset;
md_print_info(cr, fplog, "Applying core pinning offset %d\n", offset);
}
rc = get_thread_affinity_layout(fplog, cr, hwinfo,
nthread_node,
offset, &hw_opt->core_pinning_stride,
&locality_order);
if (rc != 0)
{
/* Incompatible layout, don't pin, warning was already issued */
return;
}
/* Set the per-thread affinity. In order to be able to check the success
* of affinity settings, we will set nth_affinity_set to 1 on threads
* where the affinity setting succeded and to 0 where it failed.
* Reducing these 0/1 values over the threads will give the total number
* of threads on which we succeeded.
*/
nth_affinity_set = 0;
#pragma omp parallel firstprivate(thread_id_node) num_threads(nthread_local) \
reduction(+:nth_affinity_set)
{
int index, core;
gmx_bool setaffinity_ret;
thread_id = gmx_omp_get_thread_num();
thread_id_node += thread_id;
index = offset + thread_id_node*hw_opt->core_pinning_stride;
if (locality_order != NULL)
{
core = locality_order[index];
}
else
{
core = index;
}
setaffinity_ret = tMPI_Thread_setaffinity_single(tMPI_Thread_self(), core);
/* store the per-thread success-values of the setaffinity */
nth_affinity_set = (setaffinity_ret == 0);
if (debug)
{
fprintf(debug, "On rank %2d, thread %2d, core %2d the affinity setting returned %d\n",
cr->nodeid, gmx_omp_get_thread_num(), core, setaffinity_ret);
}
}
if (nth_affinity_set > nthread_local)
{
char msg[STRLEN];
sprintf(msg, "Looks like we have set affinity for more threads than "
"we have (%d > %d)!\n", nth_affinity_set, nthread_local);
gmx_incons(msg);
}
else
{
/* check & warn if some threads failed to set their affinities */
if (nth_affinity_set != nthread_local)
{
char sbuf1[STRLEN], sbuf2[STRLEN];
/* sbuf1 contains rank info, while sbuf2 OpenMP thread info */
sbuf1[0] = sbuf2[0] = '\0';
/* Only add rank info if we have more than one rank. */
if (cr->nnodes > 1)
{
#ifdef GMX_MPI
#ifdef GMX_THREAD_MPI
sprintf(sbuf1, "In tMPI thread #%d: ", cr->nodeid);
#else /* GMX_LIB_MPI */
sprintf(sbuf1, "In MPI process #%d: ", cr->nodeid);
#endif
#endif /* GMX_MPI */
}
if (nthread_local > 1)
{
sprintf(sbuf2, "for %d/%d thread%s ",
nthread_local - nth_affinity_set, nthread_local,
nthread_local > 1 ? "s" : "");
}
md_print_warn(NULL, fplog,
"WARNING: %sAffinity setting %sfailed.\n"
" This can cause performance degradation! If you think your setting are\n"
" correct, contact the GROMACS developers.",
sbuf1, sbuf2);
}
}
return;
}
void gmx_setup_nodecomm(FILE *fplog, t_commrec *cr)
{
gmx_nodecomm_t *nc;
int n, rank, hostnum, ng, ni;
/* Many MPI implementations do not optimize MPI_Allreduce
* (and probably also other global communication calls)
* for multi-core nodes connected by a network.
* We can optimize such communication by using one MPI call
* within each node and one between the nodes.
* For MVAPICH2 and Intel MPI this reduces the time for
* the global_stat communication by 25%
* for 2x2-core 3 GHz Woodcrest connected by mixed DDR/SDR Infiniband.
* B. Hess, November 2007
*/
nc = &cr->nc;
nc->bUse = FALSE;
#ifndef GMX_THREAD_MPI
#ifdef GMX_MPI
MPI_Comm_size(cr->mpi_comm_mygroup, &n);
MPI_Comm_rank(cr->mpi_comm_mygroup, &rank);
hostnum = gmx_hostname_num();
if (debug)
{
fprintf(debug, "In gmx_setup_nodecomm: splitting communicator of size %d\n", n);
}
/* The intra-node communicator, split on node number */
MPI_Comm_split(cr->mpi_comm_mygroup, hostnum, rank, &nc->comm_intra);
MPI_Comm_rank(nc->comm_intra, &nc->rank_intra);
if (debug)
{
fprintf(debug, "In gmx_setup_nodecomm: node rank %d rank_intra %d\n",
rank, nc->rank_intra);
}
/* The inter-node communicator, split on rank_intra.
* We actually only need the one for rank=0,
* but it is easier to create them all.
*/
MPI_Comm_split(cr->mpi_comm_mygroup, nc->rank_intra, rank, &nc->comm_inter);
/* Check if this really created two step communication */
MPI_Comm_size(nc->comm_inter, &ng);
MPI_Comm_size(nc->comm_intra, &ni);
if (debug)
{
fprintf(debug, "In gmx_setup_nodecomm: groups %d, my group size %d\n",
ng, ni);
}
if (getenv("GMX_NO_NODECOMM") == NULL &&
((ng > 1 && ng < n) || (ni > 1 && ni < n)))
{
nc->bUse = TRUE;
if (fplog)
{
fprintf(fplog, "Using two step summing over %d groups of on average %.1f processes\n\n",
ng, (real)n/(real)ng);
}
if (nc->rank_intra > 0)
{
MPI_Comm_free(&nc->comm_inter);
}
}
else
{
/* One group or all processes in a separate group, use normal summing */
MPI_Comm_free(&nc->comm_inter);
MPI_Comm_free(&nc->comm_intra);
if (debug)
{
fprintf(debug, "In gmx_setup_nodecomm: not unsing separate inter- and intra-node communicators.\n");
}
}
#endif
#else
/* tMPI runs only on a single node so just use the nodeid */
nc->rank_intra = cr->nodeid;
#endif
}
