Rate This Document
Findability
Accuracy
Completeness
Readability

kupl_shm_fence

Performs inter-process synchronization on a window.

Interface Definition

int kupl_shm_fence(kupl_shm_win_h win)

Environment Variables

The KUPL_SHM_FENCE_ALGORITHM environment variable specifies the underlying algorithm used for the fence synchronization:

Possible values:

  • 1: linear
  • 2: rd (default)

Parameters

Table 1 Parameter definition

Parameter

Type

Description

Input/Output

win

kupl_shm_win_h

Window object to be synchronized.

Input

Return Value

  • Success: KUPL_OK
  • Failure: KUPL_ERROR

Examples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include <stdio.h>
#include <mpi.h>
#include <unistd.h>
#include "kupl.h"
 
#define ITERS 5
// 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 win;
    void *baseptr;
    size_t bufsize = sizeof(int);
    ret = kupl_shm_win_alloc(bufsize, kupl_comm, &baseptr, &win);
    if (ret != KUPL_OK) {
        fprintf(stderr, "kupl baseptr alloc failed: %d\n", ret);
        return -1;
    }
    ((int *)baseptr)[0] = 0;
    for (int i = 0; i < ITERS; i++) {
        ((int *)baseptr)[0]++;
        kupl_shm_fence(win);
        if ((world_rank & 1) == 1) {
            usleep(100);
        } else {
            usleep(10000);
        }
    }
    kupl_shm_win_free(win);
    kupl_shm_comm_destroy(kupl_comm);
    MPI_Finalize();
    return 0;
}

The preceding example demonstrates the workflow of using the KUPL fence. The kupl_shm_fence function synchronizes all processes within the window.