Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
sds
ssg
Commits
40f22c2a
Commit
40f22c2a
authored
Apr 07, 2016
by
Jonathan Jenkins
Browse files
rm NA usage
parent
84902954
Pipeline
#10
skipped
Changes
4
Pipelines
1
Hide whitespace changes
Inline
Side-by-side
examples/ssg-example.c
View file @
40f22c2a
...
...
@@ -9,7 +9,6 @@
#include <string.h>
#include <mercury.h>
#include <na.h>
#include <mercury_util/mercury_request.h>
#include <ssg.h>
#include <ssg-config.h>
...
...
@@ -61,8 +60,6 @@ static int trigger(unsigned int timeout, unsigned int *flag, void *arg)
int
main
(
int
argc
,
char
*
argv
[])
{
// mercury
na_class_t
*
nacl
;
na_context_t
*
nactx
;
hg_class_t
*
hgcl
;
hg_context_t
*
hgctx
;
hg_request_class_t
*
reqcl
;
...
...
@@ -81,12 +78,11 @@ int main(int argc, char *argv[])
// comm vars
int
peer_rank
;
na
_addr_t
peer_addr
;
hg
_addr_t
peer_addr
;
ping_t
ping_in
;
unsigned
int
req_complete_flag
=
0
;
// return codes
na_return_t
nret
;
hg_return_t
hret
;
int
ret
;
...
...
@@ -108,12 +104,8 @@ int main(int argc, char *argv[])
addr_str
=
argv
[
0
];
argc
--
;
argv
++
;
// init NA, HG
nacl
=
NA_Initialize
(
addr_str
,
NA_TRUE
);
DIE_IF
(
nacl
==
NULL
,
"NA_Initialize"
);
nactx
=
NA_Context_create
(
nacl
);
DIE_IF
(
nactx
==
NULL
,
"NA_Context_create"
);
hgcl
=
HG_Init_na
(
nacl
,
nactx
);
// init HG
hgcl
=
HG_Init
(
addr_str
,
HG_TRUE
);
DIE_IF
(
hgcl
==
NULL
,
"HG_Init"
);
hgctx
=
HG_Context_create
(
hgcl
);
DIE_IF
(
hgctx
==
NULL
,
"HG_Context_create"
);
...
...
@@ -134,7 +126,7 @@ int main(int argc, char *argv[])
argc
--
;
argv
++
;
if
(
strcmp
(
mode
,
"mpi"
)
==
0
)
{
#ifdef HAVE_MPI
c
.
s
=
ssg_init_mpi
(
na
cl
,
MPI_COMM_WORLD
);
c
.
s
=
ssg_init_mpi
(
hg
cl
,
MPI_COMM_WORLD
);
sleep_time
=
0
;
// ignore sleeping
#else
fprintf
(
stderr
,
"Error: MPI support not built in
\n
"
);
...
...
@@ -158,8 +150,8 @@ int main(int argc, char *argv[])
if
(
sleep_time
>=
0
)
sleep
(
sleep_time
);
// resolve group addresses
n
ret
=
ssg_lookup
(
nacl
,
na
ctx
,
c
.
s
);
DIE_IF
(
n
ret
!=
NA
_SUCCESS
,
"ssg_lookup"
);
h
ret
=
ssg_lookup
(
hg
ctx
,
c
.
s
);
DIE_IF
(
h
ret
!=
HG
_SUCCESS
,
"ssg_lookup"
);
// get my (non-mpi) rank
rank
=
ssg_get_rank
(
c
.
s
);
...
...
@@ -179,7 +171,7 @@ int main(int argc, char *argv[])
// all ready to go - ping my neighbor rank
peer_rank
=
(
rank
+
1
)
%
ssg_get_count
(
c
.
s
);
peer_addr
=
ssg_get_addr
(
c
.
s
,
peer_rank
);
DIE_IF
(
peer_addr
==
NA
_ADDR_NULL
,
"ssg_get_addr(%d)"
,
peer_rank
);
DIE_IF
(
peer_addr
==
HG
_ADDR_NULL
,
"ssg_get_addr(%d)"
,
peer_rank
);
printf
(
"%d: pinging %d
\n
"
,
rank
,
peer_rank
);
hret
=
HG_Create
(
hgctx
,
peer_addr
,
ping_id
,
&
ping_handle
);
...
...
@@ -234,8 +226,6 @@ cleanup:
hg_request_finalize
(
reqcl
);
HG_Context_destroy
(
hgctx
);
HG_Finalize
(
hgcl
);
NA_Context_destroy
(
nacl
,
nactx
);
NA_Finalize
(
nacl
);
#ifdef HAVE_MPI
MPI_Finalize
();
...
...
include/ssg.h
View file @
40f22c2a
...
...
@@ -16,9 +16,8 @@ extern "C" {
#endif
#include <mercury.h>
#include <na.h>
// using pointer so that we can use proc
// using pointer so that we can use proc
(proc has to allocate in this case)
typedef
struct
ssg
*
ssg_t
;
// some defines
...
...
@@ -36,12 +35,9 @@ typedef struct ssg *ssg_t;
// containing a set of hostnames
ssg_t
ssg_init_config
(
const
char
*
fname
);
// once the ssg has been initialized, wireup (a collection of
NA
_Addr_lookups)
// once the ssg has been initialized, wireup (a collection of
HG
_Addr_lookups)
// note that this is a simple blocking implementation - no margo/etc here
na_return_t
ssg_lookup
(
na_class_t
*
nacl
,
na_context_t
*
nactx
,
ssg_t
s
);
hg_return_t
ssg_lookup
(
hg_context_t
*
hgctx
,
ssg_t
s
);
/// finalization
...
...
@@ -57,7 +53,7 @@ int ssg_get_rank(const ssg_t s);
int
ssg_get_count
(
const
ssg_t
s
);
// get the address for the group member at the given rank
na
_addr_t
ssg_get_addr
(
const
ssg_t
s
,
int
rank
);
hg
_addr_t
ssg_get_addr
(
const
ssg_t
s
,
int
rank
);
// get the string hostname for the group member at the given rank
const
char
*
ssg_get_addr_str
(
const
ssg_t
s
,
int
rank
);
...
...
src/def.h
View file @
40f22c2a
...
...
@@ -2,9 +2,9 @@
struct
ssg
{
na
_class_t
*
na
cl
;
hg
_class_t
*
hg
cl
;
char
**
addr_strs
;
na
_addr_t
*
addrs
;
hg
_addr_t
*
addrs
;
void
*
backing_buf
;
int
num_addrs
;
int
buf_size
;
...
...
src/ssg.c
View file @
40f22c2a
...
...
@@ -16,13 +16,12 @@
#endif
// helpers for looking up a server
static
na_return_t
lookup_serv_addr_cb
(
const
struct
na_cb_info
*
info
);
static
na_addr_t
lookup_serv_addr
(
na_class_t
*
nacl
,
na_context_t
*
nactx
,
static
hg_return_t
lookup_serv_addr_cb
(
const
struct
hg_cb_info
*
info
);
static
hg_addr_t
lookup_serv_addr
(
hg_context_t
*
hgctx
,
const
char
*
info_str
);
static
na
_return_t
find_rank
(
na
_class_t
*
na
cl
,
ssg_t
s
);
static
hg
_return_t
find_rank
(
hg
_class_t
*
hg
cl
,
ssg_t
s
);
static
char
**
setup_addr_str_list
(
int
num_addrs
,
char
*
buf
);
...
...
@@ -105,10 +104,10 @@ ssg_t ssg_init_config(const char * fname)
// done parsing - setup the return structure
s
=
malloc
(
sizeof
(
*
s
));
if
(
s
==
NULL
)
goto
fini
;
s
->
na
cl
=
NULL
;
s
->
hg
cl
=
NULL
;
s
->
addrs
=
malloc
(
num_addrs
*
sizeof
(
*
s
->
addrs
));
if
(
s
->
addrs
==
NULL
)
goto
fini
;
for
(
int
i
=
0
;
i
<
num_addrs
;
i
++
)
s
->
addrs
[
i
]
=
NA
_ADDR_NULL
;
for
(
int
i
=
0
;
i
<
num_addrs
;
i
++
)
s
->
addrs
[
i
]
=
HG
_ADDR_NULL
;
s
->
addr_strs
=
addr_strs
;
addr_strs
=
NULL
;
s
->
backing_buf
=
buf
;
buf
=
NULL
;
s
->
num_addrs
=
num_addrs
;
...
...
@@ -125,12 +124,12 @@ fini:
}
#ifdef HAVE_MPI
ssg_t
ssg_init_mpi
(
na
_class_t
*
na
cl
,
MPI_Comm
comm
)
ssg_t
ssg_init_mpi
(
hg
_class_t
*
hg
cl
,
MPI_Comm
comm
)
{
// my addr
na
_addr_t
self_addr
=
NA
_ADDR_NULL
;
hg
_addr_t
self_addr
=
HG
_ADDR_NULL
;
char
*
self_addr_str
=
NULL
;
na
_size_t
self_addr_size
=
0
;
hg
_size_t
self_addr_size
=
0
;
int
self_addr_size_int
=
0
;
// for mpi-friendly conversion
// collective helpers
...
...
@@ -140,25 +139,25 @@ ssg_t ssg_init_mpi(na_class_t *nacl, MPI_Comm comm)
int
comm_size
=
0
;
int
comm_rank
=
0
;
//
na
addresses
na
_addr_t
*
addrs
=
NULL
;
//
hg
addresses
hg
_addr_t
*
addrs
=
NULL
;
// return data
char
**
addr_strs
=
NULL
;
ssg_t
s
=
NULL
;
// misc return codes
na
_return_t
n
ret
;
hg
_return_t
h
ret
;
// get my address
n
ret
=
NA
_Addr_self
(
na
cl
,
&
self_addr
);
if
(
n
ret
!=
NA
_SUCCESS
)
goto
fini
;
n
ret
=
NA
_Addr_to_string
(
na
cl
,
NULL
,
&
self_addr_size
,
self_addr
);
h
ret
=
HG
_Addr_self
(
hg
cl
,
&
self_addr
);
if
(
h
ret
!=
HG
_SUCCESS
)
goto
fini
;
h
ret
=
HG
_Addr_to_string
(
hg
cl
,
NULL
,
&
self_addr_size
,
self_addr
);
if
(
self_addr
==
NULL
)
goto
fini
;
self_addr_str
=
malloc
(
self_addr_size
);
if
(
self_addr_str
==
NULL
)
goto
fini
;
n
ret
=
NA
_Addr_to_string
(
na
cl
,
self_addr_str
,
&
self_addr_size
,
self_addr
);
if
(
n
ret
!=
NA
_SUCCESS
)
goto
fini
;
h
ret
=
HG
_Addr_to_string
(
hg
cl
,
self_addr_str
,
&
self_addr_size
,
self_addr
);
if
(
h
ret
!=
HG
_SUCCESS
)
goto
fini
;
self_addr_size_int
=
(
int
)
self_addr_size
;
// null char included in call
// gather the buffer sizes
...
...
@@ -190,23 +189,23 @@ ssg_t ssg_init_mpi(na_class_t *nacl, MPI_Comm comm)
// init peer addresses
addrs
=
malloc
(
comm_size
*
sizeof
(
*
addrs
));
if
(
addrs
==
NULL
)
goto
fini
;
for
(
int
i
=
0
;
i
<
comm_size
;
i
++
)
addrs
[
i
]
=
NA
_ADDR_NULL
;
for
(
int
i
=
0
;
i
<
comm_size
;
i
++
)
addrs
[
i
]
=
HG
_ADDR_NULL
;
addrs
[
comm_rank
]
=
self_addr
;
// set up the output
s
=
malloc
(
sizeof
(
*
s
));
if
(
s
==
NULL
)
goto
fini
;
s
->
na
cl
=
NULL
;
s
->
hg
cl
=
NULL
;
// set in ssg_lookup
s
->
addr_strs
=
addr_strs
;
addr_strs
=
NULL
;
s
->
addrs
=
addrs
;
addrs
=
NULL
;
s
->
backing_buf
=
buf
;
buf
=
NULL
;
s
->
num_addrs
=
comm_size
;
s
->
buf_size
=
sizes_psum
[
comm_size
];
s
->
rank
=
comm_rank
;
self_addr
=
NA
_ADDR_NULL
;
// don't free this on success
self_addr
=
HG
_ADDR_NULL
;
// don't free this on success
fini:
if
(
self_addr
!=
NA
_ADDR_NULL
)
NA
_Addr_free
(
na
cl
,
self_addr
);
if
(
self_addr
!=
HG
_ADDR_NULL
)
HG
_Addr_free
(
hg
cl
,
self_addr
);
free
(
buf
);
free
(
sizes
);
free
(
addr_strs
);
...
...
@@ -215,53 +214,51 @@ fini:
}
#endif
na_return_t
ssg_lookup
(
na_class_t
*
nacl
,
na_context_t
*
nactx
,
ssg_t
s
)
hg_return_t
ssg_lookup
(
hg_context_t
*
hgctx
,
ssg_t
s
)
{
// "effective" rank for the lookup loop
int
eff_rank
=
0
;
// set the network class up front - will use when destructing
s
->
nacl
=
nacl
;
// set the hg class up front - need for destructing addrs
s
->
hgcl
=
HG_Context_get_class
(
hgctx
);
if
(
s
->
hgcl
==
NULL
)
return
HG_INVALID_PARAM
;
// perform search for my rank if not already set
if
(
s
->
rank
==
SSG_RANK_UNKNOWN
)
{
na
_return_t
n
ret
=
find_rank
(
na
cl
,
s
);
if
(
n
ret
!=
NA
_SUCCESS
)
return
n
ret
;
hg
_return_t
h
ret
=
find_rank
(
s
->
hg
cl
,
s
);
if
(
h
ret
!=
HG
_SUCCESS
)
return
h
ret
;
}
if
(
s
->
rank
==
SSG_EXTERNAL_RANK
)
{
// do a completely arbitrary effective rank determination to try and
// prevent everyone talking to the same member at once
eff_rank
=
(((
intptr_t
)
nacl
)
/
sizeof
(
nacl
))
%
s
->
num_addrs
;
eff_rank
=
(((
intptr_t
)
hgctx
)
/
sizeof
(
hgctx
))
%
s
->
num_addrs
;
}
else
eff_rank
=
s
->
rank
;
// rank is set, perform lookup
for
(
int
i
=
eff_rank
+
1
;
i
<
s
->
num_addrs
;
i
++
)
{
s
->
addrs
[
i
]
=
lookup_serv_addr
(
nacl
,
na
ctx
,
s
->
addr_strs
[
i
]);
if
(
s
->
addrs
[
i
]
==
NA
_ADDR_NULL
)
return
NA
_PROTOCOL_ERROR
;
s
->
addrs
[
i
]
=
lookup_serv_addr
(
hg
ctx
,
s
->
addr_strs
[
i
]);
if
(
s
->
addrs
[
i
]
==
HG
_ADDR_NULL
)
return
HG
_PROTOCOL_ERROR
;
}
for
(
int
i
=
0
;
i
<
eff_rank
;
i
++
)
{
s
->
addrs
[
i
]
=
lookup_serv_addr
(
nacl
,
na
ctx
,
s
->
addr_strs
[
i
]);
if
(
s
->
addrs
[
i
]
==
NA
_ADDR_NULL
)
return
NA
_PROTOCOL_ERROR
;
s
->
addrs
[
i
]
=
lookup_serv_addr
(
hg
ctx
,
s
->
addr_strs
[
i
]);
if
(
s
->
addrs
[
i
]
==
HG
_ADDR_NULL
)
return
HG
_PROTOCOL_ERROR
;
}
if
(
s
->
rank
==
SSG_EXTERNAL_RANK
)
{
s
->
addrs
[
eff_rank
]
=
lookup_serv_addr
(
nacl
,
na
ctx
,
s
->
addr_strs
[
eff_rank
]);
if
(
s
->
addrs
[
eff_rank
]
==
NA
_ADDR_NULL
)
return
NA
_PROTOCOL_ERROR
;
lookup_serv_addr
(
hg
ctx
,
s
->
addr_strs
[
eff_rank
]);
if
(
s
->
addrs
[
eff_rank
]
==
HG
_ADDR_NULL
)
return
HG
_PROTOCOL_ERROR
;
}
return
NA
_SUCCESS
;
return
HG
_SUCCESS
;
}
void
ssg_finalize
(
ssg_t
s
)
{
for
(
int
i
=
0
;
i
<
s
->
num_addrs
;
i
++
)
{
if
(
s
->
addrs
[
i
]
!=
NA
_ADDR_NULL
)
NA
_Addr_free
(
s
->
na
cl
,
s
->
addrs
[
i
]);
if
(
s
->
addrs
[
i
]
!=
HG
_ADDR_NULL
)
HG
_Addr_free
(
s
->
hg
cl
,
s
->
addrs
[
i
]);
}
free
(
s
->
backing_buf
);
free
(
s
->
addr_strs
);
...
...
@@ -279,12 +276,12 @@ int ssg_get_count(const ssg_t s)
return
s
->
num_addrs
;
}
na
_addr_t
ssg_get_addr
(
const
ssg_t
s
,
int
rank
)
hg
_addr_t
ssg_get_addr
(
const
ssg_t
s
,
int
rank
)
{
if
(
rank
>=
0
||
rank
<
s
->
num_addrs
)
return
s
->
addrs
[
rank
];
else
return
NA
_ADDR_NULL
;
return
HG
_ADDR_NULL
;
}
const
char
*
ssg_get_addr_str
(
const
ssg_t
s
,
int
rank
)
...
...
@@ -297,7 +294,7 @@ const char * ssg_get_addr_str(const ssg_t s, int rank)
// serialization format looks like:
// < num members, buffer size, buffer... >
// doesn't attempt to grab
na
_addr's, string buffers, etc. - client will be
// doesn't attempt to grab
hg
_addr's, string buffers, etc. - client will be
// responsible for doing a separate address lookup routine
hg_return_t
hg_proc_ssg_t
(
hg_proc_t
proc
,
ssg_t
*
s
)
{
...
...
@@ -369,7 +366,7 @@ hg_return_t hg_proc_ssg_t(hg_proc_t proc, ssg_t *s)
goto
end
;
}
for
(
int
i
=
0
;
i
<
ss
->
num_addrs
;
i
++
)
{
ss
->
addrs
[
i
]
=
NA
_ADDR_NULL
;
ss
->
addrs
[
i
]
=
HG
_ADDR_NULL
;
}
// success: set the output
...
...
@@ -402,84 +399,83 @@ end:
typedef
struct
serv_addr_out
{
na
_addr_t
addr
;
hg
_addr_t
addr
;
int
set
;
}
serv_addr_out_t
;
static
na
_return_t
lookup_serv_addr_cb
(
const
struct
na
_cb_info
*
info
)
static
hg
_return_t
lookup_serv_addr_cb
(
const
struct
hg
_cb_info
*
info
)
{
serv_addr_out_t
*
out
=
info
->
arg
;
out
->
addr
=
info
->
info
.
lookup
.
addr
;
out
->
set
=
1
;
return
NA
_SUCCESS
;
return
HG
_SUCCESS
;
}
static
na_addr_t
lookup_serv_addr
(
na_class_t
*
nacl
,
na_context_t
*
nactx
,
static
hg_addr_t
lookup_serv_addr
(
hg_context_t
*
hgctx
,
const
char
*
info_str
)
{
serv_addr_out_t
out
;
na
_return_t
n
ret
;
hg
_return_t
h
ret
;
out
.
addr
=
NA
_ADDR_NULL
;
out
.
addr
=
HG
_ADDR_NULL
;
out
.
set
=
0
;
n
ret
=
NA
_Addr_lookup
(
nacl
,
na
ctx
,
&
lookup_serv_addr_cb
,
&
out
,
info_str
,
NA
_OP_ID_IGNORE
);
if
(
n
ret
!=
NA
_SUCCESS
)
return
NA
_ADDR_NULL
;
h
ret
=
HG
_Addr_lookup
(
hg
ctx
,
&
lookup_serv_addr_cb
,
&
out
,
info_str
,
HG
_OP_ID_IGNORE
);
if
(
h
ret
!=
HG
_SUCCESS
)
return
HG
_ADDR_NULL
;
// run the progress loop until we've got the output
do
{
unsigned
int
count
=
0
;
do
{
n
ret
=
NA
_Trigger
(
na
ctx
,
0
,
1
,
&
count
);
}
while
(
n
ret
==
NA
_SUCCESS
&&
count
>
0
);
h
ret
=
HG
_Trigger
(
hg
ctx
,
0
,
1
,
&
count
);
}
while
(
h
ret
==
HG
_SUCCESS
&&
count
>
0
);
if
(
out
.
set
!=
0
)
break
;
n
ret
=
NA
_Progress
(
nacl
,
na
ctx
,
5000
);
}
while
(
n
ret
==
NA
_SUCCESS
||
n
ret
==
NA
_TIMEOUT
);
h
ret
=
HG
_Progress
(
hg
ctx
,
5000
);
}
while
(
h
ret
==
HG
_SUCCESS
||
h
ret
==
HG
_TIMEOUT
);
return
out
.
addr
;
}
static
na
_return_t
find_rank
(
na
_class_t
*
na
cl
,
ssg_t
s
)
static
hg
_return_t
find_rank
(
hg
_class_t
*
hg
cl
,
ssg_t
s
)
{
// helpers
na
_addr_t
self_addr
=
NA
_ADDR_NULL
;
hg
_addr_t
self_addr
=
HG
_ADDR_NULL
;
char
*
self_addr_str
=
NULL
;
const
char
*
self_addr_substr
=
NULL
;
na
_size_t
self_addr_size
=
0
;
hg
_size_t
self_addr_size
=
0
;
const
char
*
addr_substr
=
NULL
;
int
rank
=
0
;
na
_return_t
n
ret
;
hg
_return_t
h
ret
;
// get my address
n
ret
=
NA
_Addr_self
(
na
cl
,
&
self_addr
);
if
(
n
ret
!=
NA
_SUCCESS
)
goto
end
;
n
ret
=
NA
_Addr_to_string
(
na
cl
,
NULL
,
&
self_addr_size
,
self_addr
);
if
(
self_addr
==
NULL
)
{
n
ret
=
NA
_NOMEM_ERROR
;
goto
end
;
}
h
ret
=
HG
_Addr_self
(
hg
cl
,
&
self_addr
);
if
(
h
ret
!=
HG
_SUCCESS
)
goto
end
;
h
ret
=
HG
_Addr_to_string
(
hg
cl
,
NULL
,
&
self_addr_size
,
self_addr
);
if
(
self_addr
==
NULL
)
{
h
ret
=
HG
_NOMEM_ERROR
;
goto
end
;
}
self_addr_str
=
malloc
(
self_addr_size
);
if
(
self_addr_str
==
NULL
)
{
n
ret
=
NA
_NOMEM_ERROR
;
goto
end
;
}
n
ret
=
NA
_Addr_to_string
(
na
cl
,
self_addr_str
,
&
self_addr_size
,
self_addr
);
if
(
n
ret
!=
NA
_SUCCESS
)
goto
end
;
if
(
self_addr_str
==
NULL
)
{
h
ret
=
HG
_NOMEM_ERROR
;
goto
end
;
}
h
ret
=
HG
_Addr_to_string
(
hg
cl
,
self_addr_str
,
&
self_addr_size
,
self_addr
);
if
(
h
ret
!=
HG
_SUCCESS
)
goto
end
;
// strstr is used here b/c there may be inconsistencies in whether the class
// is included in the address or not (it's not in
NA
_Addr_to_string, it
// is included in the address or not (it's not in
HG
_Addr_to_string, it
// should be in ssg_init_config)
self_addr_substr
=
strstr
(
self_addr_str
,
"://"
);
if
(
self_addr_substr
==
NULL
)
{
n
ret
=
NA
_INVALID_PARAM
;
goto
end
;
}
if
(
self_addr_substr
==
NULL
)
{
h
ret
=
HG
_INVALID_PARAM
;
goto
end
;
}
self_addr_substr
+=
3
;
for
(
rank
=
0
;
rank
<
s
->
num_addrs
;
rank
++
)
{
addr_substr
=
strstr
(
s
->
addr_strs
[
rank
],
"://"
);
if
(
addr_substr
==
NULL
)
{
n
ret
=
NA
_INVALID_PARAM
;
goto
end
;
}
if
(
addr_substr
==
NULL
)
{
h
ret
=
HG
_INVALID_PARAM
;
goto
end
;
}
addr_substr
+=
3
;
if
(
strcmp
(
self_addr_substr
,
addr_substr
)
==
0
)
break
;
}
if
(
rank
==
s
->
num_addrs
)
{
n
ret
=
NA
_INVALID_PARAM
;
h
ret
=
HG
_INVALID_PARAM
;
goto
end
;
}
...
...
@@ -488,10 +484,10 @@ static na_return_t find_rank(na_class_t *nacl, ssg_t s)
s
->
addrs
[
rank
]
=
self_addr
;
self_addr
=
NULL
;
end:
if
(
self_addr
!=
NA
_ADDR_NULL
)
NA
_Addr_free
(
na
cl
,
self_addr
);
if
(
self_addr
!=
HG
_ADDR_NULL
)
HG
_Addr_free
(
hg
cl
,
self_addr
);
free
(
self_addr_str
);
return
n
ret
;
return
h
ret
;
}
static
char
**
setup_addr_str_list
(
int
num_addrs
,
char
*
buf
)
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment