int pmixp_lib_finalize(void)
{
int rc = SLURM_SUCCESS;
/* deregister the errhandler */
PMIx_Deregister_event_handler(0, _op_callbk, NULL);
if (PMIX_SUCCESS != PMIx_server_finalize()) {
rc = SLURM_ERROR;
}
return rc;
}
int pmixp_libpmix_finalize(void)
{
int rc = SLURM_SUCCESS, rc1;
/* deregister the errhandler */
PMIx_Deregister_errhandler(0, op_callbk, NULL);
if (PMIX_SUCCESS != PMIx_server_finalize()) {
rc = SLURM_ERROR;
}
rc1 = pmixp_rmdir_recursively(pmixp_info_tmpdir_lib());
if (0 == rc) {
/* return only one error :) */
rc = rc1;
}
return rc;
}
int main(int argc, char **argv)
{
char **client_env=NULL;
char **client_argv=NULL;
int rc;
struct stat stat_buf;
struct timeval tv;
double test_start;
cli_state_t order[CLI_TERM+1];
test_params params;
INIT_TEST_PARAMS(params);
int test_fail = 0;
char *tmp;
int ns_nprocs;
gettimeofday(&tv, NULL);
test_start = tv.tv_sec + 1E-6*tv.tv_usec;
/* smoke test */
if (PMIX_SUCCESS != 0) {
TEST_ERROR(("ERROR IN COMPUTING CONSTANTS: PMIX_SUCCESS = %d", PMIX_SUCCESS));
exit(1);
}
TEST_VERBOSE(("Testing version %s", PMIx_Get_version()));
parse_cmd(argc, argv, ¶ms);
TEST_VERBOSE(("Start PMIx_lite smoke test (timeout is %d)", params.timeout));
/* verify executable */
if( 0 > ( rc = stat(params.binary, &stat_buf) ) ){
TEST_ERROR(("Cannot stat() executable \"%s\": %d: %s", params.binary, errno, strerror(errno)));
FREE_TEST_PARAMS(params);
return 0;
} else if( !S_ISREG(stat_buf.st_mode) ){
TEST_ERROR(("Client executable \"%s\": is not a regular file", params.binary));
FREE_TEST_PARAMS(params);
return 0;
}else if( !(stat_buf.st_mode & S_IXUSR) ){
TEST_ERROR(("Client executable \"%s\": has no executable flag", params.binary));
FREE_TEST_PARAMS(params);
return 0;
}
/* setup the server library */
pmix_info_t info[1];
(void)strncpy(info[0].key, PMIX_SOCKET_MODE, PMIX_MAX_KEYLEN);
info[0].value.type = PMIX_UINT32;
info[0].value.data.uint32 = 0666;
if (PMIX_SUCCESS != (rc = PMIx_server_init(&mymodule, info, 1))) {
TEST_ERROR(("Init failed with error %d", rc));
FREE_TEST_PARAMS(params);
return rc;
}
/* register the errhandler */
PMIx_Register_event_handler(NULL, 0, NULL, 0,
errhandler, errhandler_reg_callbk, NULL);
order[CLI_UNINIT] = CLI_FORKED;
order[CLI_FORKED] = CLI_FIN;
order[CLI_CONNECTED] = CLI_UNDEF;
order[CLI_FIN] = CLI_TERM;
order[CLI_DISCONN] = CLI_UNDEF;
order[CLI_TERM] = CLI_UNDEF;
cli_init(params.nprocs, order);
/* set common argv and env */
client_env = pmix_argv_copy(environ);
set_client_argv(¶ms, &client_argv);
tmp = pmix_argv_join(client_argv, ' ');
TEST_VERBOSE(("Executing test: %s", tmp));
free(tmp);
int launched = 0;
/* set namespaces and fork clients */
if (NULL == params.ns_dist) {
/* we have a single namespace for all clients */
ns_nprocs = params.nprocs;
rc = launch_clients(ns_nprocs, params.binary, &client_env, &client_argv);
if (PMIX_SUCCESS != rc) {
FREE_TEST_PARAMS(params);
return rc;
}
launched += ns_nprocs;
} else {
char *pch;
pch = strtok(params.ns_dist, ":");
while (NULL != pch) {
ns_nprocs = (int)strtol(pch, NULL, 10);
if (params.nprocs < (uint32_t)(launched+ns_nprocs)) {
TEST_ERROR(("Total number of processes doesn't correspond number specified by ns_dist parameter."));
FREE_TEST_PARAMS(params);
return PMIX_ERROR;
}
if (0 < ns_nprocs) {
rc = launch_clients(ns_nprocs, params.binary, &client_env, &client_argv);
if (PMIX_SUCCESS != rc) {
FREE_TEST_PARAMS(params);
return rc;
}
}
pch = strtok (NULL, ":");
launched += ns_nprocs;
}
}
if (params.nprocs != (uint32_t)launched) {
TEST_ERROR(("Total number of processes doesn't correspond number specified by ns_dist parameter."));
cli_kill_all();
test_fail = 1;
}
/* hang around until the client(s) finalize */
while (!test_terminated()) {
// To avoid test hang we want to interrupt the loop each 0.1s
double test_current;
// check if we exceed the max time
gettimeofday(&tv, NULL);
test_current = tv.tv_sec + 1E-6*tv.tv_usec;
if( (test_current - test_start) > params.timeout ){
break;
}
cli_wait_all(0);
}
if( !test_terminated() ){
TEST_ERROR(("Test exited by a timeout!"));
cli_kill_all();
test_fail = 1;
}
if( test_abort ){
TEST_ERROR(("Test was aborted!"));
/* do not simply kill the clients as that generates
* event notifications which these tests then print
* out, flooding the log */
// cli_kill_all();
test_fail = 1;
}
if (0 != params.test_spawn) {
PMIX_WAIT_FOR_COMPLETION(spawn_wait);
}
pmix_argv_free(client_argv);
pmix_argv_free(client_env);
/* deregister the errhandler */
PMIx_Deregister_event_handler(0, op_callbk, NULL);
cli_wait_all(1.0);
/* finalize the server library */
if (PMIX_SUCCESS != (rc = PMIx_server_finalize())) {
TEST_ERROR(("Finalize failed with error %d", rc));
}
FREE_TEST_PARAMS(params);
if (0 == test_fail) {
TEST_OUTPUT(("Test finished OK!"));
}
return test_fail;
}
int launch_clients(int num_procs, char *binary, char *** client_env, char ***base_argv)
{
int n;
uid_t myuid;
gid_t mygid;
char *ranks = NULL;
char digit[MAX_DIGIT_LEN];
int rc;
static int counter = 0;
static int num_ns = 0;
pmix_proc_t proc;
TEST_VERBOSE(("Setting job info"));
fill_seq_ranks_array(num_procs, counter, &ranks);
if (NULL == ranks) {
PMIx_server_finalize();
TEST_ERROR(("fill_seq_ranks_array failed"));
return PMIX_ERROR;
}
(void)snprintf(proc.nspace, PMIX_MAX_NSLEN, "%s-%d", TEST_NAMESPACE, num_ns);
set_namespace(num_procs, ranks, proc.nspace);
if (NULL != ranks) {
free(ranks);
}
myuid = getuid();
mygid = getgid();
/* fork/exec the test */
for (n = 0; n < num_procs; n++) {
proc.rank = counter;
if (PMIX_SUCCESS != (rc = PMIx_server_setup_fork(&proc, client_env))) {//n
TEST_ERROR(("Server fork setup failed with error %d", rc));
PMIx_server_finalize();
cli_kill_all();
return rc;
}
if (PMIX_SUCCESS != (rc = PMIx_server_register_client(&proc, myuid, mygid, NULL, NULL, NULL))) {//n
TEST_ERROR(("Server fork setup failed with error %d", rc));
PMIx_server_finalize();
cli_kill_all();
return rc;
}
cli_info[counter].pid = fork();
if (cli_info[counter].pid < 0) {
TEST_ERROR(("Fork failed"));
PMIx_server_finalize();
cli_kill_all();
return -1;
}
cli_info[counter].rank = counter;//n
cli_info[counter].ns = strdup(proc.nspace);
char **client_argv = pmix_argv_copy(*base_argv);
/* add two last arguments: -r <rank> */
sprintf(digit, "%d", counter);//n
pmix_argv_append_nosize(&client_argv, "-r");
pmix_argv_append_nosize(&client_argv, digit);
pmix_argv_append_nosize(&client_argv, "-s");
pmix_argv_append_nosize(&client_argv, proc.nspace);
sprintf(digit, "%d", num_procs);
pmix_argv_append_nosize(&client_argv, "--ns-size");
pmix_argv_append_nosize(&client_argv, digit);
sprintf(digit, "%d", num_ns);
pmix_argv_append_nosize(&client_argv, "--ns-id");
pmix_argv_append_nosize(&client_argv, digit);
sprintf(digit, "%d", (counter-n));
pmix_argv_append_nosize(&client_argv, "--base-rank");
pmix_argv_append_nosize(&client_argv, digit);
if (cli_info[counter].pid == 0) {
if( !TEST_VERBOSE_GET() ){
// Hide clients stdout
// TODO: on some systems stdout is a constant, address this
fclose(stdout);
stdout = fopen("/dev/null","w");
}
execve(binary, client_argv, *client_env);
/* Does not return */
exit(0);
}
cli_info[counter].state = CLI_FORKED;
pmix_argv_free(client_argv);
counter++;
}
num_ns++;
return PMIX_SUCCESS;
}