我不想mpiexec -n 4 ./a.out在我的核心 i7 处理器（有 4 个内核）上运行我的程序。相反，我想运行./a.out，让它检测内核数量并启动 MPI 以运行每个内核的进程。
这个 SO 问答MPI 处理器数量？引导我使用mpiexec。
我想避免使用 mpiexec 的原因是因为我的代码注定要成为我正在处理的更大项目中的库。较大的项目有一个 GUI，用户将开始长时间的计算，这些计算将调用我的库，而我的库又将使用 MPI。UI 和计算代码之间的集成不是微不足道的……因此启动外部进程并通过套接字或其他方式进行通信不是一种选择。它必须是一个库调用。
这可能吗？我该怎么做？
一般来说，这是一件非常重要的事情。此外，几乎没有任何便携式解决方案不依赖于某些 MPI 实现细节。下面是一个示例解决方案，它适用于 Open MPI，也可能适用于其他通用 MPI 实现（MPICH、Intel MPI 等）。它涉及第二个可执行文件或原始可执行文件直接调用您提供一些特殊命令行参数的库的方法。它是这样的。
假设原始可执行文件只是作为./a.out. 当您的库函数被调用时，它会调用MPI_Init(NULL, NULL)，从而初始化 MPI。由于该可执行文件不是通过 启动的mpiexec，它退回到所谓的单例 MPI 初始化，即它创建一个由单个进程组成的 MPI 作业。要执行分布式计算，您必须启动更多 MPI 进程，而这正是一般情况下事情变得复杂的地方。
MPI 支持动态进程管理，其中一个 MPI 作业可以启动第二个作业并使用互通器与其进行通信。当第一个作业调用MPI_Comm_spawn或时会发生这种情况MPI_Comm_spawn_multiple。第一个用于启动对所有 MPI 等级使用相同可执行文件的简单 MPI 作业，而第二个可以启动混合不同可执行文件的作业。两者都需要有关在何处以及如何启动进程的信息。这来自所谓的MPI Universe，它不仅提供有关已启动进程的信息，还提供有关动态启动进程的可用插槽的信息。宇宙是由mpiexec或者通过一些其他启动器机制，例如，带有节点列表和每个节点上的插槽数的主机文件。如果没有此类信息，某些 MPI 实现（包括 Open MPI）将简单地在与原始文件相同的节点上启动可执行文件。MPI_Comm_spawn[_multiple]有一个MPI_Info参数，可用于提供具有实现特定信息的键值巴黎列表。Open MPI 支持add-hostfile可用于指定生成子作业时要使用的主机文件的密钥。这对于例如允许用户通过 GUI 指定用于 MPI 计算的主机列表很有用。但是让我们专注于没有提供此类信息并且 Open MPI 只是在同一主机上运行子作业的情况。
假设 worker 可执行文件被调用worker。或者，例如，如果使用某些特殊的命令行选项调用，则原始可执行文件可以用作工作程序-worker。如果要对N进程进行整体计算，则需要启动N-1工作线程。这很简单：
（单独的可执行文件）
MPI_Comm child_comm;
MPI_Comm_spawn("./worker", MPI_ARGV_NULL, N-1, MPI_INFO_NULL, 0,
MPI_COMM_SELF, &child_comm, MPI_ERRCODES_IGNORE);
（相同的可执行文件，有一个选项）
MPI_Comm child_comm;
char *argv[] = { "-worker", NULL };
MPI_Comm_spawn("./a.out", argv, N-1, MPI_INFO_NULL, 0,
MPI_COMM_SELF, &child_comm, MPI_ERRCODES_IGNORE);
如果一切顺利的话，child_comm将被设置为一个手柄intercommunicator可用于对新工作进行沟通。由于对讲机使用起来有点棘手，而且亲子分工需要复杂的程序逻辑，因此可以简单地将对讲机的两侧合并成一个“大世界”的通讯机，取代MPI_COMM_WORLD. 在父母方面：
MPI_Comm bigworld;
MPI_Intercomm_merge(child_comm, 0, &bigworld);
在孩子这边：
MPI_Comm parent_comm, bigworld;
MPI_Get_parent(&parent_comm);
MPI_Intercomm_merge(parent_comm, 1, &bigworld);
合并完成后，所有进程都可以使用bigworld代替 进行通信MPI_COMM_WORLD。请注意，子作业不MPI_COMM_WORLD与父作业共享。
总而言之，这是一个完整的功能示例，其中包含两个单独的程序代码。
main.c
#include <stdio.h>
#include <mpi.h>
int main (void)
{
MPI_Init(NULL, NULL);
printf("[main] Spawning workers...\n");
MPI_Comm child_comm;
MPI_Comm_spawn("./worker", MPI_ARGV_NULL, 2, MPI_INFO_NULL, 0,
MPI_COMM_SELF, &child_comm, MPI_ERRCODES_IGNORE);
MPI_Comm bigworld;
MPI_Intercomm_merge(child_comm, 0, &bigworld);
int size, rank;
MPI_Comm_rank(bigworld, &rank);
MPI_Comm_size(bigworld, &size);
printf("[main] Big world created with %d ranks\n", size);
// Perform some computation
int data = 1, result;
MPI_Bcast(&data, 1, MPI_INT, 0, bigworld);
data *= (1 + rank);
MPI_Reduce(&data, &result, 1, MPI_INT, MPI_SUM, 0, bigworld);
printf("[main] Result = %d\n", result);
MPI_Barrier(bigworld);
MPI_Comm_free(&bigworld);
MPI_Comm_free(&child_comm);
MPI_Finalize();
printf("[main] Shutting down\n");
return 0;
}
worker.c
#include <stdio.h>
#include <mpi.h>
int main (void)
{
MPI_Init(NULL, NULL);
MPI_Comm parent_comm;
MPI_Comm_get_parent(&parent_comm);
int rank, size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
printf("[worker] %d of %d here\n", rank, size);
MPI_Comm bigworld;
MPI_Intercomm_merge(parent_comm, 1, &bigworld);
MPI_Comm_rank(bigworld, &rank);
MPI_Comm_size(bigworld, &size);
printf("[worker] %d of %d in big world\n", rank, size);
// Perform some computation
int data;
MPI_Bcast(&data, 1, MPI_INT, 0, bigworld);
data *= (1 + rank);
MPI_Reduce(&data, NULL, 1, MPI_INT, MPI_SUM, 0, bigworld);
printf("[worker] Done\n");
MPI_Barrier(bigworld);
MPI_Comm_free(&bigworld);
MPI_Comm_free(&parent_comm);
MPI_Finalize();
return 0;
}
下面是它的工作原理：
$ mpicc -o main main.c
$ mpicc -o worker worker.c
$ ./main
[main] Spawning workers...
[worker] 0 of 2 here
[worker] 1 of 2 here
[worker] 1 of 3 in big world
[worker] 2 of 3 in big world
[main] Big world created with 3 ranks
[worker] Done
[worker] Done
[main] Result = 6
[main] Shutting down
必须使用子作业MPI_Comm_get_parent来获取父作业的互通器。当进程不属于此类子作业时，返回值将为MPI_COMM_NULL。这允许在同一个可执行文件中实现主程序和工作程序的简单方法。这是一个混合示例：
#include <stdio.h>
#include <mpi.h>
MPI_Comm bigworld_comm = MPI_COMM_NULL;
MPI_Comm other_comm = MPI_COMM_NULL;
int parlib_init (const char *argv0, int n)
{
MPI_Init(NULL, NULL);
MPI_Comm_get_parent(&other_comm);
if (other_comm == MPI_COMM_NULL)
{
printf("[main] Spawning workers...\n");
MPI_Comm_spawn(argv0, MPI_ARGV_NULL, n-1, MPI_INFO_NULL, 0,
MPI_COMM_SELF, &other_comm, MPI_ERRCODES_IGNORE);
MPI_Intercomm_merge(other_comm, 0, &bigworld_comm);
return 0;
}
int rank, size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
printf("[worker] %d of %d here\n", rank, size);
MPI_Intercomm_merge(other_comm, 1, &bigworld_comm);
return 1;
}
int parlib_dowork (void)
{
int data = 1, result = -1, size, rank;
MPI_Comm_rank(bigworld_comm, &rank);
MPI_Comm_size(bigworld_comm, &size);
if (rank == 0)
{
printf("[main] Doing work with %d processes in total\n", size);
data = 1;
}
MPI_Bcast(&data, 1, MPI_INT, 0, bigworld_comm);
data *= (1 + rank);
MPI_Reduce(&data, &result, 1, MPI_INT, MPI_SUM, 0, bigworld_comm);
return result;
}
void parlib_finalize (void)
{
MPI_Comm_free(&bigworld_comm);
MPI_Comm_free(&other_comm);
MPI_Finalize();
}
int main (int argc, char **argv)
{
if (parlib_init(argv[0], 4))
{
// Worker process
(void)parlib_dowork();
printf("[worker] Done\n");
parlib_finalize();
return 0;
}
// Main process
// Show GUI, save the world, etc.
int result = parlib_dowork();
printf("[main] Result = %d\n", result);
parlib_finalize();
printf("[main] Shutting down\n");
return 0;
}
这是一个示例输出：
$ mpicc -o hybrid hybrid.c
$ ./hybrid
[main] Spawning workers...
[worker] 0 of 3 here
[worker] 2 of 3 here
[worker] 1 of 3 here
[main] Doing work with 4 processes in total
[worker] Done
[worker] Done
[main] Result = 10
[worker] Done
[main] Shutting down
设计此类并行库时要记住的一些事项：
MPI_Initialized以检查库是否已初始化。MPI_Finalized是你的朋友。它可以用于类似atexit()处理程序的东西，以在程序退出时实现通用 MPI 终结。MPI_Init_thread。