← Back to branch summary

~ubuntu-branches/ubuntu/vivid/mpich/vivid-proposed

« back to all changes in this revision

Viewing changes to src/pmi/smpd/smpd_pmi.c

  • Committer: Package Import Robot
  • Author(s): Anton Gladky
  • Date: 2014-04-01 20:24:20 UTC
  • mfrom: (5.2.4 sid)
  • Revision ID: package-import@ubuntu.com-20140401202420-t5ey1ia2klt5dkq3
Tags: 3.1-4
http://bugs.debian.org/743047
* [c3e3398] Disable test_primitives, which is unreliable on some platforms.
            (Closes: #743047)
* [265a699] Add minimal autotest.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pmi/smpd/smpd_pmi.c
1
 
/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
2
 
/*
3
 
 *  (C) 2001 by Argonne National Laboratory.
4
 
 *      See COPYRIGHT in top-level directory.
5
 
 */
6
 
#include "ipmi.h"
7
 
#ifdef HAVE_MACH_O_DYLD_H
8
 
#include <mach-o/dyld.h>
9
 
#endif
10
 
 
11
 
#ifdef HAVE_WINDOWS_H
12
 
 
13
 
#define PMILoadLibrary(a,b) a = LoadLibrary( b )
14
 
#define PMIGetProcAddress GetProcAddress
15
 
#define PMIModule HMODULE
16
 
 
17
 
#elif defined(HAVE_DLOPEN)
18
 
 
19
 
#define PMILoadLibrary(a, b) a = dlopen( b , RTLD_LAZY /* or RTLD_NOW */)
20
 
#define PMIGetProcAddress dlsym
21
 
#define PMIModule void *
22
 
 
23
 
#elif defined(HAVE_NSLINKMODULE)
24
 
 
25
 
#define PMILoadLibrary(a, b) \
26
 
{ \
27
 
    NSObjectFileImage fileImage; \
28
 
    NSObjectFileImageReturnCode returnCode = \
29
 
        NSCreateObjectFileImageFromFile(b, &fileImage); \
30
 
    if (returnCode == NSObjectFileImageSuccess) \
31
 
    { \
32
 
        a = NSLinkModule(fileImage, b, \
33
 
                         NSLINKMODULE_OPTION_RETURN_ON_ERROR \
34
 
                         | NSLINKMODULE_OPTION_PRIVATE); \
35
 
        NSDestroyObjectFileImage(fileImage); \
36
 
    } else { \
37
 
        a = NULL; \
38
 
    } \
39
 
}
40
 
#define PMIGetProcAddress(a, b) NSAddressOfSymbol( NSLookupSymbolInModule( a, b ) )
41
 
#define PMIModule NSModule
42
 
 
43
 
#else
44
 
#error PMILoadLibrary functions needed
45
 
#endif
46
 
 
47
 
/* global variables */
48
 
static ipmi_functions_t fn =
49
 
{
50
 
    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
51
 
};
52
 
 
53
 
int PMI_Init(int *spawned)
54
 
{
55
 
    char *dll_name;
56
 
    PMIModule hModule;
57
 
 
58
 
    if (fn.PMI_Init != NULL)
59
 
    {
60
 
        /* Init cannot be called more than once? */
61
 
        return PMI_FAIL;
62
 
    }
63
 
 
64
 
    dll_name = getenv("PMI_DLL_NAME");
65
 
    if (dll_name)
66
 
    {
67
 
        PMILoadLibrary(hModule, dll_name);
68
 
        if (hModule != NULL)
69
 
        {
70
 
            fn.PMI_Init = (int (*)(int *))PMIGetProcAddress(hModule, "PMI_Init");
71
 
            if (fn.PMI_Init == NULL)
72
 
            {
73
 
                return PMI_FAIL;
74
 
            }
75
 
            fn.PMI_Initialized = (int (*)(int *))PMIGetProcAddress(hModule, "PMI_Initialized");
76
 
            fn.PMI_Finalize = (int (*)(void))PMIGetProcAddress(hModule, "PMI_Finalize");
77
 
            fn.PMI_Get_size = (int (*)(int *))PMIGetProcAddress(hModule, "PMI_Get_size");
78
 
            fn.PMI_Get_rank = (int (*)(int *))PMIGetProcAddress(hModule, "PMI_Get_rank");
79
 
            fn.PMI_Get_universe_size = (int (*)(int *))PMIGetProcAddress(hModule, "PMI_Get_universe_size");
80
 
            fn.PMI_Get_appnum = (int (*)(int *))PMIGetProcAddress(hModule, "PMI_Get_appnum");
81
 
            fn.PMI_Get_id = (int (*)(char [], int))PMIGetProcAddress(hModule, "PMI_Get_id");
82
 
            fn.PMI_Get_kvs_domain_id = (int (*)(char [], int))PMIGetProcAddress(hModule, "PMI_Get_kvs_domain_id");
83
 
            fn.PMI_Get_id_length_max = (int (*)(int *))PMIGetProcAddress(hModule, "PMI_Get_id_length_max");
84
 
            fn.PMI_Barrier = (int (*)(void))PMIGetProcAddress(hModule, "PMI_Barrier");
85
 
            fn.PMI_Get_clique_size = (int (*)(int *))PMIGetProcAddress(hModule, "PMI_Get_clique_size");
86
 
            fn.PMI_Get_clique_ranks = (int (*)(int [], int))PMIGetProcAddress(hModule, "PMI_Get_clique_ranks");
87
 
            fn.PMI_Abort = (int (*)(int, const char[]))PMIGetProcAddress(hModule, "PMI_Abort");
88
 
            fn.PMI_KVS_Get_my_name = (int (*)(char [], int))PMIGetProcAddress(hModule, "PMI_KVS_Get_my_name");
89
 
            fn.PMI_KVS_Get_name_length_max = (int (*)(int *))PMIGetProcAddress(hModule, "PMI_KVS_Get_name_length_max");
90
 
            fn.PMI_KVS_Get_key_length_max = (int (*)(int *))PMIGetProcAddress(hModule, "PMI_KVS_Get_key_length_max");
91
 
            fn.PMI_KVS_Get_value_length_max = (int (*)(int *))PMIGetProcAddress(hModule, "PMI_KVS_Get_value_length_max");
92
 
            fn.PMI_KVS_Create = (int (*)(char [], int))PMIGetProcAddress(hModule, "PMI_KVS_Create");
93
 
            fn.PMI_KVS_Destroy = (int (*)(const char []))PMIGetProcAddress(hModule, "PMI_KVS_Destroy");
94
 
            fn.PMI_KVS_Put = (int (*)(const char [], const char [], const char []))PMIGetProcAddress(hModule, "PMI_KVS_Put");
95
 
            fn.PMI_KVS_Commit = (int (*)(const char []))PMIGetProcAddress(hModule, "PMI_KVS_Commit");
96
 
            fn.PMI_KVS_Get = (int (*)(const char [], const char [], char [], int))PMIGetProcAddress(hModule, "PMI_KVS_Get");
97
 
            fn.PMI_KVS_Iter_first = (int (*)(const char [], char [], int, char [], int))PMIGetProcAddress(hModule, "PMI_KVS_Iter_first");
98
 
            fn.PMI_KVS_Iter_next = (int (*)(const char [], char [], int, char [], int))PMIGetProcAddress(hModule, "PMI_KVS_Iter_next");
99
 
            fn.PMI_Spawn_multiple = (int (*)(int, const char *[], const char **[], const int [], const int [], const PMI_keyval_t *[], int, const PMI_keyval_t [], int []))PMIGetProcAddress(hModule, "PMI_Spawn_multiple");
100
 
            fn.PMI_Parse_option = (int (*)(int, char *[], int *, PMI_keyval_t **, int *))PMIGetProcAddress(hModule, "PMI_Parse_option");
101
 
            fn.PMI_Args_to_keyval = (int (*)(int *, char *((*)[]), PMI_keyval_t **, int *))PMIGetProcAddress(hModule, "PMI_Args_to_keyval");
102
 
            fn.PMI_Free_keyvals = (int (*)(PMI_keyval_t [], int))PMIGetProcAddress(hModule, "PMI_Free_keyvals");
103
 
            fn.PMI_Publish_name = (int (*)(const char [], const char [] ))PMIGetProcAddress(hModule, "PMI_Publish_name");
104
 
            fn.PMI_Unpublish_name = (int (*)( const char [] ))PMIGetProcAddress(hModule, "PMI_Unpublish_name");
105
 
            fn.PMI_Lookup_name = (int (*)( const char [], char [] ))PMIGetProcAddress(hModule, "PMI_Lookup_name");
106
 
            return fn.PMI_Init(spawned);
107
 
        }
108
 
    }
109
 
 
110
 
    fn.PMI_Init = iPMI_Init;
111
 
    fn.PMI_Initialized = iPMI_Initialized;
112
 
    fn.PMI_Finalize = iPMI_Finalize;
113
 
    fn.PMI_Get_size = iPMI_Get_size;
114
 
    fn.PMI_Get_rank = iPMI_Get_rank;
115
 
    fn.PMI_Get_universe_size = iPMI_Get_universe_size;
116
 
    fn.PMI_Get_appnum = iPMI_Get_appnum;
117
 
    fn.PMI_Get_id = iPMI_Get_id;
118
 
    fn.PMI_Get_kvs_domain_id = iPMI_Get_kvs_domain_id;
119
 
    fn.PMI_Get_id_length_max = iPMI_Get_id_length_max;
120
 
    fn.PMI_Barrier = iPMI_Barrier;
121
 
    fn.PMI_Get_clique_size = iPMI_Get_clique_size;
122
 
    fn.PMI_Get_clique_ranks = iPMI_Get_clique_ranks;
123
 
    fn.PMI_Abort = iPMI_Abort;
124
 
    fn.PMI_KVS_Get_my_name = iPMI_KVS_Get_my_name;
125
 
    fn.PMI_KVS_Get_name_length_max = iPMI_KVS_Get_name_length_max;
126
 
    fn.PMI_KVS_Get_key_length_max = iPMI_KVS_Get_key_length_max;
127
 
    fn.PMI_KVS_Get_value_length_max = iPMI_KVS_Get_value_length_max;
128
 
    fn.PMI_KVS_Create = iPMI_KVS_Create;
129
 
    fn.PMI_KVS_Destroy = iPMI_KVS_Destroy;
130
 
    fn.PMI_KVS_Put = iPMI_KVS_Put;
131
 
    fn.PMI_KVS_Commit = iPMI_KVS_Commit;
132
 
    fn.PMI_KVS_Get = iPMI_KVS_Get;
133
 
    fn.PMI_KVS_Iter_first = iPMI_KVS_Iter_first;
134
 
    fn.PMI_KVS_Iter_next = iPMI_KVS_Iter_next;
135
 
    fn.PMI_Spawn_multiple = iPMI_Spawn_multiple;
136
 
    fn.PMI_Parse_option = iPMI_Parse_option;
137
 
    fn.PMI_Args_to_keyval = iPMI_Args_to_keyval;
138
 
    fn.PMI_Free_keyvals = iPMI_Free_keyvals;
139
 
    fn.PMI_Publish_name = iPMI_Publish_name;
140
 
    fn.PMI_Unpublish_name = iPMI_Unpublish_name;
141
 
    fn.PMI_Lookup_name = iPMI_Lookup_name;
142
 
 
143
 
    return fn.PMI_Init(spawned);
144
 
}
145
 
 
146
 
int PMI_Finalize()
147
 
{
148
 
    if (fn.PMI_Finalize == NULL)
149
 
        return PMI_FAIL;
150
 
    return fn.PMI_Finalize();
151
 
}
152
 
 
153
 
int PMI_Get_size(int *size)
154
 
{
155
 
    if (fn.PMI_Get_size == NULL)
156
 
        return PMI_FAIL;
157
 
    return fn.PMI_Get_size(size);
158
 
}
159
 
 
160
 
int PMI_Get_rank(int *rank)
161
 
{
162
 
    if (fn.PMI_Get_rank == NULL)
163
 
        return PMI_FAIL;
164
 
    return fn.PMI_Get_rank(rank);
165
 
}
166
 
 
167
 
int PMI_Get_universe_size(int *size)
168
 
{
169
 
    if (fn.PMI_Get_universe_size == NULL)
170
 
        return PMI_FAIL;
171
 
    return fn.PMI_Get_universe_size(size);
172
 
}
173
 
 
174
 
int PMI_Get_appnum(int *appnum)
175
 
{
176
 
    if (fn.PMI_Get_appnum == NULL)
177
 
        return PMI_FAIL;
178
 
    return fn.PMI_Get_appnum(appnum);
179
 
}
180
 
 
181
 
int PMI_Barrier()
182
 
{
183
 
    if (fn.PMI_Barrier == NULL)
184
 
        return PMI_FAIL;
185
 
    return fn.PMI_Barrier();
186
 
}
187
 
 
188
 
int PMI_Abort(int exit_code, const char error_msg[])
189
 
{
190
 
    if (fn.PMI_Abort == NULL)
191
 
        return PMI_FAIL;
192
 
    return fn.PMI_Abort(exit_code, error_msg);
193
 
}
194
 
 
195
 
int PMI_KVS_Get_my_name(char kvsname[], int length)
196
 
{
197
 
    if (fn.PMI_KVS_Get_my_name == NULL)
198
 
        return PMI_FAIL;
199
 
    return fn.PMI_KVS_Get_my_name(kvsname, length);
200
 
}
201
 
 
202
 
int PMI_KVS_Get_name_length_max(int *maxlen)
203
 
{
204
 
    if (fn.PMI_KVS_Get_name_length_max == NULL)
205
 
        return PMI_FAIL;
206
 
    return fn.PMI_KVS_Get_name_length_max(maxlen);
207
 
}
208
 
 
209
 
int PMI_KVS_Get_key_length_max(int *maxlen)
210
 
{
211
 
    if (fn.PMI_KVS_Get_key_length_max == NULL)
212
 
        return PMI_FAIL;
213
 
    return fn.PMI_KVS_Get_key_length_max(maxlen);
214
 
}
215
 
 
216
 
int PMI_KVS_Get_value_length_max(int *maxlen)
217
 
{
218
 
    if (fn.PMI_KVS_Get_value_length_max == NULL)
219
 
        return PMI_FAIL;
220
 
    return fn.PMI_KVS_Get_value_length_max(maxlen);
221
 
}
222
 
 
223
 
int PMI_KVS_Put(const char kvsname[], const char key[], const char value[])
224
 
{
225
 
    if (fn.PMI_KVS_Put == NULL)
226
 
        return PMI_FAIL;
227
 
    return fn.PMI_KVS_Put(kvsname, key, value);
228
 
}
229
 
 
230
 
int PMI_KVS_Commit(const char kvsname[])
231
 
{
232
 
    if (fn.PMI_KVS_Commit == NULL)
233
 
        return PMI_FAIL;
234
 
    return fn.PMI_KVS_Commit(kvsname);
235
 
}
236
 
 
237
 
int PMI_KVS_Get(const char kvsname[], const char key[], char value[], int length)
238
 
{
239
 
    if (fn.PMI_KVS_Get == NULL)
240
 
        return PMI_FAIL;
241
 
    return fn.PMI_KVS_Get(kvsname, key, value, length);
242
 
}
243
 
 
244
 
int PMI_Spawn_multiple(int count,
245
 
                       const char * cmds[],
246
 
                       const char ** argvs[],
247
 
                       const int maxprocs[],
248
 
                       const int info_keyval_sizes[],
249
 
                       const PMI_keyval_t * info_keyval_vectors[],
250
 
                       int preput_keyval_size,
251
 
                       const PMI_keyval_t preput_keyval_vector[],
252
 
                       int errors[])
253
 
{
254
 
    if (fn.PMI_Spawn_multiple == NULL)
255
 
        return PMI_FAIL;
256
 
    return fn.PMI_Spawn_multiple(count, cmds, argvs, maxprocs,
257
 
        info_keyval_sizes, info_keyval_vectors,
258
 
        preput_keyval_size, preput_keyval_vector,
259
 
        errors);
260
 
}
261
 
 
262
 
int PMI_Publish_name( const char service_name[], const char port[] )
263
 
{
264
 
    if (fn.PMI_Publish_name == NULL)
265
 
        return PMI_FAIL;
266
 
    return fn.PMI_Publish_name(service_name, port);
267
 
}
268
 
 
269
 
int PMI_Unpublish_name( const char service_name[] )
270
 
{
271
 
    if (fn.PMI_Unpublish_name == NULL)
272
 
        return PMI_FAIL;
273
 
    return fn.PMI_Unpublish_name(service_name);
274
 
}
275
 
 
276
 
int PMI_Lookup_name( const char service_name[], char port[] )
277
 
{
278
 
    if (fn.PMI_Lookup_name == NULL)
279
 
        return PMI_FAIL;
280
 
    return fn.PMI_Lookup_name(service_name, port);
281
 
}