server.c 4.59 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
/*
 * (C) 2015 The University of Chicago
 * 
 * See COPYRIGHT in top-level directory.
 */

#include <stdio.h>
#include <assert.h>
#include <unistd.h>
#include <abt.h>
Philip Carns's avatar
Philip Carns committed
11
12
#include <abt-snoozer.h>
#include <margo.h>
13
14
15
16
17
18
19
20
21
22
23

#include "my-rpc.h"

/* example server program.  Starts HG engine, registers the example RPC type,
 * and then executes indefinitely.
 */

int main(int argc, char **argv) 
{
    int ret;
    ABT_eventual eventual;
24
    int *shutdown;
25
    margo_instance_id mid;
26
27
28
29
    ABT_xstream handler_xstream;
    ABT_pool handler_pool;
    ABT_xstream progress_xstream;
    ABT_pool progress_pool;
30
31
32
33
    na_class_t *network_class;
    na_context_t *na_context;
    hg_context_t *hg_context;
    hg_class_t *hg_class;
34
    int single_pool_mode = 0;
35
    
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
    if(argc > 2)
    {
        fprintf(stderr, "Usage: ./server <single>\n");
        fprintf(stderr, "   Note: the optional \"single\" argument makes the server use a single ABT pool for both HG progress and RPC handlers.\n");
        return(-1);
    }

    if(argc == 2)
    {
        if(strcmp(argv[1], "single") == 0)
            single_pool_mode = 1;
        else
        {
            fprintf(stderr, "Usage: ./server <single>\n");
            fprintf(stderr, "   Note: the optional \"single\" argument makes the server use a single ABT pool for both HG progress and RPC handlers.\n");
            return(-1);
        }
    }

55
    /* boilerplate HG initialization steps */
56
    /***************************************/
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
    network_class = NA_Initialize("tcp://localhost:1234", NA_TRUE);
    if(!network_class)
    {
        fprintf(stderr, "Error: NA_Initialize()\n");
        return(-1);
    }
    na_context = NA_Context_create(network_class);
    if(!na_context)
    {
        fprintf(stderr, "Error: NA_Context_create()\n");
        NA_Finalize(network_class);
        return(-1);
    }
    hg_class = HG_Init(network_class, na_context, NULL);
    if(!hg_class)
    {
        fprintf(stderr, "Error: HG_Init()\n");
        NA_Context_destroy(network_class, na_context);
        NA_Finalize(network_class);
        return(-1);
    }
    hg_context = HG_Context_create(hg_class);
    if(!hg_context)
    {
        fprintf(stderr, "Error: HG_Context_create()\n");
        HG_Finalize(hg_class);
        NA_Context_destroy(network_class, na_context);
        NA_Finalize(network_class);
        return(-1);
    }

    /* set up argobots */
89
    /***************************************/
90
91
92
93
94
95
96
    ret = ABT_init(argc, argv);
    if(ret != 0)
    {
        fprintf(stderr, "Error: ABT_init()\n");
        return(-1);
    }

Philip Carns's avatar
Philip Carns committed
97
98
    /* set primary ES to idle without polling */
    ret = ABT_snoozer_xstream_self_set();
99
100
    if(ret != 0)
    {
Philip Carns's avatar
Philip Carns committed
101
        fprintf(stderr, "Error: ABT_snoozer_xstream_self_set()\n");
102
103
104
        return(-1);
    }

105
106
107
108
109
110
111
112
113
114
115
116
117
118
    /* Find primary pool to use for running rpc handlers */
    ret = ABT_xstream_self(&handler_xstream);
    if(ret != 0)
    {
        fprintf(stderr, "Error: ABT_xstream_self()\n");
        return(-1);
    }
    ret = ABT_xstream_get_main_pools(handler_xstream, 1, &handler_pool);
    if(ret != 0)
    {
        fprintf(stderr, "Error: ABT_xstream_get_main_pools()\n");
        return(-1);
    }

119
    if(!single_pool_mode)
120
    {
121
122
123
124
125
126
127
        /* create a dedicated ES drive Mercury progress */
        ret = ABT_snoozer_xstream_create(1, &progress_pool, &progress_xstream);
        if(ret != 0)
        {
            fprintf(stderr, "Error: ABT_snoozer_xstream_create()\n");
            return(-1);
        }
128
129
    }

130
    /* actually start margo */
131
132
133
134
135
    /* provide argobots pools for driving communication progress and
     * executing rpc handlers as well as class and context for Mercury
     * communication.
     */
    /***************************************/
136
137
138
139
    if(single_pool_mode)
        mid = margo_init(handler_pool, handler_pool, hg_context, hg_class);
    else
        mid = margo_init(progress_pool, handler_pool, hg_context, hg_class);
140
141

    /* register RPC */
142
143
    MERCURY_REGISTER(hg_class, "my_rpc", my_rpc_in_t, my_rpc_out_t, 
        my_rpc_ult_handler);
144
145

    /* suspend this ULT until someone tells us to shut down */
146
    ret = ABT_eventual_create(sizeof(*shutdown), &eventual);
147
148
149
150
151
152
153
154
    if(ret != 0)
    {
        fprintf(stderr, "Error: ABT_eventual_create()\n");
        return(-1);
    }

    ABT_eventual_wait(eventual, (void**)&shutdown);

155
    /* shut down everything */
156
    margo_finalize(mid);
157

158
159
160
161
162
    if(!single_pool_mode)
    {
        ABT_xstream_join(progress_xstream);
        ABT_xstream_free(&progress_xstream);
    }
163

164
165
    ABT_finalize();

166
167
168
169
170
    HG_Context_destroy(hg_context);
    HG_Finalize(hg_class);
    NA_Context_destroy(network_class, na_context);
    NA_Finalize(network_class);

171
172
173
    return(0);
}