kupl_shm_bcast_init

#include <stdio.h>
#include <mpi.h>
#include <unistd.h>
#include "kupl.h"

// Callback 1 required for creating a KUPL communicator.
static int oob_barrier_callback(void *group)
{
    return MPI_Barrier((MPI_Comm)group);
}
// Callback 2 required for creating a KUPL communicator.
static int oob_allgather_callback(const void *sendbuf, void *recvbuf, int size, void *group,
                                  kupl_shm_datatype_t datatype)
{
    switch (datatype) {
        case KUPL_SHM_DATATYPE_CHAR:
            return MPI_Allgather(sendbuf, size, MPI_CHAR, recvbuf, size, MPI_CHAR, (MPI_Comm)group);
        default:
            fprintf(stderr, "not support datatype");
            return KUPL_ERROR;
    }
}
int main(int argc, char *argv[])
{
    // Initialize the MPI environment.
    MPI_Init(&argc, &argv);
    MPI_Comm comm = MPI_COMM_WORLD;
    // Obtain the size of the MPI communicator.
    int world_size;
    MPI_Comm_size(comm, &world_size);
    // Obtain the rank of the process.
    int world_rank;
    MPI_Comm_rank(comm, &world_rank);
    // Obtain the PID.
    int pid = getpid();
    // Create a KUPL communicator.
    kupl_shm_oob_cb_t oob_cbs;
    kupl_shm_oob_cb_h oob_cbs_h = &oob_cbs;
    oob_cbs_h->oob_allgather = oob_allgather_callback;
    oob_cbs_h->oob_barrier = oob_barrier_callback;
    kupl_shm_comm_h kupl_comm;
    int ret = kupl_shm_comm_create(world_size, world_rank, pid, oob_cbs_h, (void *)comm, &kupl_comm);
    if (ret != KUPL_OK || kupl_comm == NULL) {
        fprintf(stderr, "kupl shm comm create failed: %d\n", ret);
        return -1;
    }
    kupl_shm_win_h kupl_win;
    kupl_shm_win_h ompi_win;
    void *kuplbuf = NULL;
    void *ompibuf = NULL;
    int count = 16000;
    int broadcast_root = 0;
    size_t buf_size = sizeof(char) * count;
    ret = kupl_shm_win_alloc(buf_size, kupl_comm, &kuplbuf, &kupl_win);
    if (ret != KUPL_OK) {
        fprintf(stderr, "kupl kuplbuf alloc failed: %d\n", ret);
        return -1;
    }
    ret = kupl_shm_win_alloc(buf_size, kupl_comm, &ompibuf, &ompi_win);
    if (ret != KUPL_OK) {
        fprintf(stderr, "kupl ompibuf alloc failed: %d\n", ret);
        kupl_shm_win_free(kupl_win);
        return -1;
    }
    auto *t_kuplbuf = static_cast<char *>(kuplbuf);
    auto *t_ompibuf = static_cast<char *>(ompibuf);
    if (world_rank == broadcast_root) {
        for (int i = 0; i < count; i++) {
            t_kuplbuf[i] = i;
            t_ompibuf[i] = i;
        }
    }
    kupl_shm_request_h request;
    MPI_Barrier(comm);
    kupl_shm_bcast_init(kuplbuf, count, KUPL_SHM_DATATYPE_CHAR, broadcast_root, kupl_comm, &request);
    kupl_shm_request_start(request);
    kupl_shm_request_wait(request);
    kupl_shm_request_free(request);
    MPI_Barrier(comm);
    MPI_Bcast(ompibuf, count, MPI_CHAR, broadcast_root, comm);
    int check = 0;
    for (int i = 0; i < count; i++) {
        if (t_kuplbuf[i] != t_ompibuf[i]) {
            check = 1;
            break;
        }
    }
    int result = 0;
    MPI_Reduce(&check, &result, 1, MPI_INT, MPI_SUM, 0, comm);
    if (result == 0) {
        printf("check success\n");
    } else {
        printf("check failed\n");
    }
    kupl_shm_win_free(kupl_win);
    kupl_shm_win_free(ompi_win);
    kuplbuf = NULL;
    ompibuf = NULL;
    kupl_shm_comm_destroy(kupl_comm);
    MPI_Finalize();
    return 0;
}