ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

Add ability to trap and propagate SIGUSR1/2 to remote processes. There are a number of small changes that hit a bunch of files:

Просмотр исходного кода 
1. Changed the RMGR and PLS APIs to add "signal_job" and "signal_proc" entry points. Only the "signal_job" entries are implemented - none of the components have implementations for "signal_proc" at this time. Thus, you can signal all of the procs in a job, but cannot currently signal only one specific proc.

2. Implemented those new API functions in all components except xgrid (Brian will do so very soon). Only the rsh/ssh and fork modules have been tested, however, and only under OS-X.

3. Added signal traps and callback functions for SIGUSR1/2 to orterun/mpirun that catch those signals and call the appropriate commands to propagate them out to all processes in the job.

4. Added a new test directory under the orte branch to (eventually) hold unit and system level tests for just the run-time. Since our test branch of the repository is under restricted access, people working on the RTE were continually developing their own system-level tests - thus making it hard to help diagnose problems. I have moved the more commonly-used functions here, and added one specifically for testing the SIGUSR1/2 functionality.

I will be contacting people directly to seek help with testing the changes on more environments. Other than compile issues, you should see absolutely no change in behavior on any of your systems - this additional functionality is transparent to anyone who does not issue a SIGUSR1/2 to mpirun.

Ralph

This commit was SVN r10258.
Этот коммит содержится в:
Ralph Castain 2006-06-08 18:27:17 +00:00
родитель 08823e56fa
Коммит ee5a626d25
35 изменённых файлов: 1260 добавлений и 189 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

2
orte/mca/pls/base/base.h
Просмотреть файл

@ -120,6 +120,8 @@ extern "C" {
int orte_pls_base_proxy_mca_argv(int *argc, char ***argv);
int orte_pls_base_proxy_terminate_job(orte_jobid_t jobid);
int orte_pls_base_proxy_terminate_proc(const orte_process_name_t *proc);
int orte_pls_base_proxy_signal_job(orte_jobid_t jobid, int32_t signal);
int orte_pls_base_proxy_signal_proc(const orte_process_name_t *proc, int32_t signal);
/**
* Check that the cwd in an app context exists and is accessible.

152
orte/mca/pls/base/pls_base_proxy.c
Просмотреть файл

@ -261,3 +261,155 @@ orte_pls_base_proxy_terminate_proc(const orte_process_name_t *proc)
{
return ORTE_ERR_NOT_IMPLEMENTED;
}
/**
* This function gets called when the remote node notifies us that it has sent
* the signal to its respective child processes.
*/
static void orte_pls_rsh_signal_job_rsp(
int status,
orte_process_name_t* peer,
orte_buffer_t* rsp,
orte_rml_tag_t tag,
void* cbdata)
{
int rc;
if (ORTE_SUCCESS != (rc = orte_rmgr_base_unpack_rsp(rsp))) {
ORTE_ERROR_LOG(rc);
}
}
/**
* This function gets called when the corresponding send completes. It then generates
* a non-blocking receive so we can be notified when the action was actually completed
* on the remote node.
*/
static void orte_pls_rsh_signal_job_cb(
int status,
orte_process_name_t* peer,
orte_buffer_t* req,
orte_rml_tag_t tag,
void* cbdata)
{
/* wait for response */
int rc;
if (status < 0) {
ORTE_ERROR_LOG(status);
OBJ_RELEASE(req);
return;
}
if (0 > (rc = orte_rml.recv_buffer_nb(peer, ORTE_RML_TAG_RMGR_CLNT, 0, orte_pls_rsh_signal_job_rsp, NULL))) {
ORTE_ERROR_LOG(rc);
}
OBJ_RELEASE(req);
}
int
orte_pls_base_proxy_signal_job(orte_jobid_t jobid, int32_t signal)
{
char *keys[2];
char *jobid_string;
orte_gpr_value_t** values = NULL;
size_t i, j, num_values = 0;
orte_process_name_t proc, *pnptr;
int rc;
if (ORTE_SUCCESS != (rc = orte_ns.convert_jobid_to_string(&jobid_string, jobid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
asprintf(&keys[0], "%s-%s", ORTE_NODE_BOOTPROXY_KEY, jobid_string);
keys[1] = NULL;
rc = orte_gpr.get(
ORTE_GPR_KEYS_OR|ORTE_GPR_TOKENS_OR,
ORTE_NODE_SEGMENT,
NULL,
keys,
&num_values,
&values
);
if (rc != ORTE_SUCCESS) {
free(jobid_string);
return rc;
}
if (0 == num_values) {
rc = ORTE_ERR_NOT_FOUND;
ORTE_ERROR_LOG(rc);
goto cleanup;
}
for(i=0; i<num_values; i++) {
orte_gpr_value_t* value = values[i];
for(j=0; j<value->cnt; j++) {
orte_gpr_keyval_t* keyval = value->keyvals[j];
orte_buffer_t *cmd = OBJ_NEW(orte_buffer_t);
int ret;
if (cmd == NULL) {
rc = ORTE_ERR_OUT_OF_RESOURCE;
ORTE_ERROR_LOG(rc);
goto cleanup;
}
if (strcmp(keyval->key, keys[0]) != 0)
continue;
/** construct command */
ret = orte_rmgr_base_pack_signal_job_cmd(cmd, jobid, signal);
if (ORTE_SUCCESS != ret) {
ORTE_ERROR_LOG(ret);
OBJ_RELEASE(cmd);
rc = ret;
continue;
}
/** get the process name from the returned keyval */
if (ORTE_SUCCESS != (rc = orte_dss.get((void**)&pnptr, values[i]->keyvals[0]->value, ORTE_NAME))) {
ORTE_ERROR_LOG(rc);
OBJ_RELEASE(cmd);
rc = ret;
continue;
}
proc = *pnptr;
/** send a signal message to the bootproxy on each node */
if (0 > (ret = orte_rml.send_buffer_nb(
&proc,
cmd,
ORTE_RML_TAG_RMGR_SVC,
0,
orte_pls_rsh_signal_job_cb,
NULL))) {
ORTE_ERROR_LOG(ret);
OBJ_RELEASE(cmd);
rc = ret;
continue;
}
}
}
cleanup:
free(jobid_string);
free(keys[0]);
if (NULL != values) {
for(i=0; i<num_values; i++) {
if (NULL != values[i]) {
OBJ_RELEASE(values[i]);
}
}
if (NULL != values ) free(values);
}
return rc;
}
int
orte_pls_base_proxy_signal_proc(const orte_process_name_t *proc, int32_t signal)
{
return ORTE_ERR_NOT_IMPLEMENTED;
}

50
orte/mca/pls/bproc/pls_bproc.c
Просмотреть файл

@ -89,6 +89,8 @@ orte_pls_base_module_t orte_pls_bproc_module = {
#endif
orte_pls_bproc_terminate_job,
orte_pls_bproc_terminate_proc,
orte_pls_bproc_signal_job,
orte_pls_bproc_signal_proc,
orte_pls_bproc_finalize
};
@ -1029,6 +1031,54 @@ int orte_pls_bproc_terminate_proc(const orte_process_name_t* proc_name) {
return ORTE_SUCCESS;
}
/**
* Signal all processes associated with this job
*/
int orte_pls_bproc_signal_job(orte_jobid_t jobid, int32_t signal) {
pid_t* pids;
size_t i, num_pids;
int rc;
/* signal application process */
if(ORTE_SUCCESS != (rc = orte_pls_base_get_proc_pids(jobid, &pids, &num_pids)))
return rc;
for(i=0; i<num_pids; i++) {
if(mca_pls_bproc_component.debug) {
opal_output(0, "orte_pls_bproc: signaling proc: %d\n", pids[i]);
}
kill(pids[i], (int)signal);
}
if(NULL != pids)
free(pids);
/** dont signal daemons - this is strictly for signalling application processes */
return ORTE_SUCCESS;
}
/**
* Signal a specific process.
*/
int orte_pls_bproc_signal_proc(const orte_process_name_t* proc_name, int32_t signal) {
int rc;
pid_t pid;
if(ORTE_SUCCESS != (rc = orte_pls_base_get_proc_pid(proc_name, &pid)))
return rc;
if(kill(pid, (int)signal) != 0) {
switch(errno) {
case EINVAL:
return ORTE_ERR_BAD_PARAM;
case ESRCH:
return ORTE_ERR_NOT_FOUND;
case EPERM:
return ORTE_ERR_PERM;
default:
return ORTE_ERROR;
}
}
return ORTE_SUCCESS;
}
/**
* Module cleanup
*/

2
orte/mca/pls/bproc/pls_bproc.h
Просмотреть файл

@ -68,6 +68,8 @@ int orte_pls_bproc_finalize(void);
int orte_pls_bproc_launch(orte_jobid_t);
int orte_pls_bproc_terminate_job(orte_jobid_t);
int orte_pls_bproc_terminate_proc(const orte_process_name_t* proc_name);
int orte_pls_bproc_signal_job(orte_jobid_t, int32_t);
int orte_pls_bproc_signal_proc(const orte_process_name_t* proc_name, int32_t);
/**
* PLS bproc Component

29
orte/mca/pls/bproc_orted/pls_bproc_orted.c
Просмотреть файл

@ -58,6 +58,8 @@ orte_pls_base_module_1_0_0_t orte_pls_bproc_orted_module = {
orte_pls_bproc_orted_launch,
orte_pls_bproc_orted_terminate_job,
orte_pls_bproc_orted_terminate_proc,
orte_pls_bproc_orted_signal_job,
orte_pls_bproc_orted_signal_proc,
orte_pls_bproc_orted_finalize
};
@ -550,6 +552,33 @@ int orte_pls_bproc_orted_terminate_proc(const orte_process_name_t* proc)
return ORTE_SUCCESS;
}
/**
* Function to signal a job. Since this component only runs on remote nodes
* and doesn't actually launch any processes, this function is not needed
* so is a noop.
* @param jobid The job to signal
* @param signal The signal to send
* @retval ORTE_SUCCESS
*/
int orte_pls_bproc_orted_signal_job(orte_jobid_t jobid, int32_t signal)
{
return ORTE_SUCCESS;
}
/**
* Function to signal a process. Since this component only runs on remote nodes
* and doesn't actually launch any processes, this function is not needed
* so is a noop.
* @param proc the process's name
* @param signal The signal to send
* @retval ORTE_SUCCESS
*/
int orte_pls_bproc_orted_terminate_proc(const orte_process_name_t* proc, int32_t signal)
{
return ORTE_SUCCESS;
}
/**
* Finalizes the bproc_orted module. Cleanup tmp directory/files
* used for I/O forwarding.

2
orte/mca/pls/bproc_orted/pls_bproc_orted.h
Просмотреть файл

@ -55,6 +55,8 @@ int orte_pls_bproc_orted_finalize(void);
int orte_pls_bproc_orted_launch(orte_jobid_t);
int orte_pls_bproc_orted_terminate_job(orte_jobid_t);
int orte_pls_bproc_orted_terminate_proc(const orte_process_name_t* proc_name);
int orte_pls_bproc_orted_signal_job(orte_jobid_t, int32_t);
int orte_pls_bproc_orted_signal_proc(const orte_process_name_t* proc_name, int32_t);
/**
* PLS bproc_orted component

54
orte/mca/pls/bproc_seed/pls_bproc_seed.c
Просмотреть файл

@ -70,6 +70,8 @@ orte_pls_base_module_t orte_pls_bproc_seed_module = {
#endif
orte_pls_bproc_seed_terminate_job,
orte_pls_bproc_seed_terminate_proc,
orte_pls_bproc_seed_signal_job,
orte_pls_bproc_seed_signal_proc,
orte_pls_bproc_seed_finalize
};
@ -727,6 +729,58 @@ int orte_pls_bproc_seed_terminate_proc(const orte_process_name_t* proc_name)
return ORTE_SUCCESS;
}
/**
* Signal all processes associated with this job. Daemons are not included as this function
* only applies to application processes.
*/
int orte_pls_bproc_seed_signal_job(orte_jobid_t jobid, int32_t signal)
{
pid_t* pids;
pid_t my_pid = getpid();
size_t i, num_pids;
int rc;
/** signal application process */
if(ORTE_SUCCESS != (rc = orte_pls_base_get_proc_pids(jobid, &pids, &num_pids)))
return rc;
for(i=0; i<num_pids; i++) {
if(mca_pls_bproc_seed_component.debug) {
opal_output(0, "orte_pls_bproc: killing proc: %d\n", pids[i]);
}
kill(pids[i], (int)signal);
}
if(NULL != pids)
free(pids);
return ORTE_SUCCESS;
}
/**
* Signal a specific process.
*/
int orte_pls_bproc_seed_signal_proc(const orte_process_name_t* proc_name, int32_t signal)
{
int rc;
pid_t pid;
if(ORTE_SUCCESS != (rc = orte_pls_base_get_proc_pid(proc_name, &pid)))
return rc;
if(kill(pid, (int)signal) != 0) {
switch(errno) {
case EINVAL:
return ORTE_ERR_BAD_PARAM;
case ESRCH:
return ORTE_ERR_NOT_FOUND;
case EPERM:
return ORTE_ERR_PERM;
default:
return ORTE_ERROR;
}
}
return ORTE_SUCCESS;
}
/**
* Module cleanup
*/

2
orte/mca/pls/bproc_seed/pls_bproc_seed.h
Просмотреть файл

@ -50,6 +50,8 @@ int orte_pls_bproc_seed_finalize(void);
int orte_pls_bproc_seed_launch(orte_jobid_t);
int orte_pls_bproc_seed_terminate_job(orte_jobid_t);
int orte_pls_bproc_seed_terminate_proc(const orte_process_name_t* proc_name);
int orte_pls_bproc_seed_signal_job(orte_jobid_t, int32_t);
int orte_pls_bproc_seed_signal_proc(const orte_process_name_t* proc_name, int32_t);
/**

2
orte/mca/pls/fork/pls_fork.h
Просмотреть файл

@ -48,6 +48,8 @@ int orte_pls_fork_finalize(void);
int orte_pls_fork_launch(orte_jobid_t);
int orte_pls_fork_terminate_job(orte_jobid_t);
int orte_pls_fork_terminate_proc(const orte_process_name_t* proc_name);
int orte_pls_fork_signal_job(orte_jobid_t, int32_t);
int orte_pls_fork_signal_proc(const orte_process_name_t* proc_name, int32_t signal);
/**
* PLS Component

110
orte/mca/pls/fork/pls_fork_module.c
Просмотреть файл

@ -91,6 +91,8 @@ orte_pls_base_module_1_0_0_t orte_pls_fork_module = {
#endif
orte_pls_fork_terminate_job,
orte_pls_fork_terminate_proc,
orte_pls_fork_signal_job,
orte_pls_fork_signal_proc,
orte_pls_fork_finalize
};
@ -646,6 +648,114 @@ int orte_pls_fork_terminate_proc(const orte_process_name_t* proc)
return ORTE_ERR_NOT_IMPLEMENTED;
}
/**
* Query for all processes allocated to the job and signal
* those on the current node.
*/
int orte_pls_fork_signal_job(orte_jobid_t jobid, int32_t signal)
{
/* query for the pids allocated on this node */
char *segment;
char *keys[3];
orte_gpr_value_t** values = NULL;
size_t i, k, num_values = 0;
int rc;
opal_value_array_t pids;
pid_t pid;
/* setup the pid array */
OBJ_CONSTRUCT(&pids, opal_value_array_t);
opal_value_array_init(&pids, sizeof(pid_t));
/* query the job segment on the registry */
if(ORTE_SUCCESS != (rc = orte_schema.get_job_segment_name(&segment, jobid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
keys[0] = ORTE_NODE_NAME_KEY;
keys[1] = ORTE_PROC_PID_KEY;
keys[2] = NULL;
rc = orte_gpr.get(
ORTE_GPR_KEYS_AND|ORTE_GPR_TOKENS_OR,
segment,
NULL,
keys,
&num_values,
&values
);
if(rc != ORTE_SUCCESS) {
free(segment);
return rc;
}
for(i=0; i<num_values; i++) {
orte_gpr_value_t* value = values[i];
pid_t pid = 0, *pidptr;
for(k=0; k<value->cnt; k++) {
orte_gpr_keyval_t* keyval = value->keyvals[k];
if(strcmp(keyval->key, ORTE_NODE_NAME_KEY) == 0) {
if(orte_dss.compare(keyval->value->data, orte_system_info.nodename, ORTE_STRING) != ORTE_EQUAL) {
break;
}
} else if (strcmp(keyval->key, ORTE_PROC_PID_KEY) == 0) {
if (ORTE_SUCCESS != (rc = orte_dss.get((void**)&pidptr, keyval->value, ORTE_PID))) {
ORTE_ERROR_LOG(rc);
free(segment);
return rc;
}
pid = *pidptr;
}
}
if (0 != pid) {
opal_value_array_append_item(&pids, &pid);
}
OBJ_RELEASE(value);
}
rc = ORTE_SUCCESS;
/* If we have processes to signal, go signal them */
for (i = 0; i < opal_value_array_get_size(&pids); ++i) {
pid = OPAL_VALUE_ARRAY_GET_ITEM(&pids, pid_t, i);
if(kill(pid, (int)signal) != 0) {
switch(errno) {
case EINVAL:
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
rc = ORTE_ERR_BAD_PARAM;
break;
case ESRCH:
ORTE_ERROR_LOG(ORTE_ERR_NOT_FOUND);
rc = ORTE_ERR_NOT_FOUND;
break;
case EPERM:
ORTE_ERROR_LOG(ORTE_ERR_PERM);
rc = ORTE_ERR_PERM;
break;
default:
ORTE_ERROR_LOG(ORTE_ERROR);
rc = ORTE_ERROR;
}
}
}
OBJ_DESTRUCT(&pids);
if(NULL != values) {
free(values);
}
free(segment);
return rc;
}
int orte_pls_fork_signal_proc(const orte_process_name_t* proc, int32_t signal)
{
return ORTE_ERR_NOT_IMPLEMENTED;
}
int orte_pls_fork_finalize(void)
{
if(mca_pls_fork_component.reap) {

13
orte/mca/pls/pls.h
Просмотреть файл

@ -209,6 +209,17 @@ typedef int (*orte_pls_base_module_terminate_job_fn_t)(orte_jobid_t);
*/
typedef int (*orte_pls_base_module_terminate_proc_fn_t)(const orte_process_name_t*);
/**
* Signal any processes launched for the respective jobid by
* this component.
*/
typedef int (*orte_pls_base_module_signal_job_fn_t)(orte_jobid_t, int32_t);
/**
* Signal a specific process.
*/
typedef int (*orte_pls_base_module_signal_proc_fn_t)(const orte_process_name_t*, int32_t);
/**
* Cleanup all resources held by the module
*/
@ -221,6 +232,8 @@ struct orte_pls_base_module_1_0_0_t {
orte_pls_base_module_launch_fn_t launch;
orte_pls_base_module_terminate_job_fn_t terminate_job;
orte_pls_base_module_terminate_proc_fn_t terminate_proc;
orte_pls_base_module_signal_job_fn_t signal_job;
orte_pls_base_module_signal_proc_fn_t signal_proc;
orte_pls_base_module_finalize_fn_t finalize;
};

15
orte/mca/pls/poe/pls_poe_module.c
Просмотреть файл

@ -56,12 +56,16 @@ extern char **environ;
static int pls_poe_launch(orte_jobid_t jobid);
static int pls_poe_terminate_job(orte_jobid_t jobid);
static int pls_poe_terminate_proc(const orte_process_name_t *name);
static int pls_poe_signal_job(orte_jobid_t jobid, int32_t signal);
static int pls_poe_signal_proc(const orte_process_name_t *name, int32_t signal);
static int pls_poe_finalize(void);
orte_pls_base_module_1_0_0_t orte_pls_poe_module = {
pls_poe_launch,
pls_poe_terminate_job,
pls_poe_terminate_proc,
pls_poe_signal_job,
pls_poe_signal_proc,
pls_poe_finalize
};
@ -615,6 +619,17 @@ static int pls_poe_terminate_proc(const orte_process_name_t *name)
return ORTE_ERR_NOT_IMPLEMENTED;
}
static int pls_poe_signal_job(orte_jobid_t jobid, int32_t signal)
{
return ORTE_ERR_NOT_IMPLEMENTED;
}
static int pls_poe_signal_proc(const orte_process_name_t *name, int32_t signal)
{
return ORTE_ERR_NOT_IMPLEMENTED;
}
/**
pls_poe_finalize - clean up tempolary files
@return error number

2
orte/mca/pls/rsh/pls_rsh.h
Просмотреть файл

@ -51,6 +51,8 @@ int orte_pls_rsh_finalize(void);
int orte_pls_rsh_launch(orte_jobid_t);
int orte_pls_rsh_terminate_job(orte_jobid_t);
int orte_pls_rsh_terminate_proc(const orte_process_name_t* proc_name);
int orte_pls_rsh_signal_job(orte_jobid_t, int32_t);
int orte_pls_rsh_signal_proc(const orte_process_name_t* proc_name, int32_t);
/**
* PLS Component

12
orte/mca/pls/rsh/pls_rsh_module.c
Просмотреть файл

@ -100,6 +100,8 @@ orte_pls_base_module_1_0_0_t orte_pls_rsh_module = {
#endif
orte_pls_rsh_terminate_job,
orte_pls_rsh_terminate_proc,
orte_pls_rsh_signal_job,
orte_pls_rsh_signal_proc,
orte_pls_rsh_finalize
};
@ -1022,6 +1024,16 @@ int orte_pls_rsh_terminate_proc(const orte_process_name_t* proc)
return orte_pls_base_proxy_terminate_proc(proc);
}
int orte_pls_rsh_signal_job(orte_jobid_t jobid, int32_t signal)
{
return orte_pls_base_proxy_signal_job(jobid, signal);
}
int orte_pls_rsh_signal_proc(const orte_process_name_t* proc, int32_t signal)
{
return orte_pls_base_proxy_signal_proc(proc, signal);
}
int orte_pls_rsh_finalize(void)
{
if (mca_pls_rsh_component.reap) {

27
orte/mca/pls/slurm/pls_slurm_module.c
Просмотреть файл

@ -70,6 +70,8 @@
static int pls_slurm_launch(orte_jobid_t jobid);
static int pls_slurm_terminate_job(orte_jobid_t jobid);
static int pls_slurm_terminate_proc(const orte_process_name_t *name);
static int pls_slurm_signal_job(orte_jobid_t jobid, int32_t signal);
static int pls_slurm_signal_proc(const orte_process_name_t *name, int32_t signal);
static int pls_slurm_finalize(void);
static int pls_slurm_start_proc(int argc, char **argv, char **env,
@ -83,6 +85,8 @@ orte_pls_base_module_1_0_0_t orte_pls_slurm_module = {
pls_slurm_launch,
pls_slurm_terminate_job,
pls_slurm_terminate_proc,
pls_slurm_signal_job,
pls_slurm_signal_proc,
pls_slurm_finalize
};
@ -423,7 +427,7 @@ static int pls_slurm_terminate_job(orte_jobid_t jobid)
/* JMS need appropriate code here to reap */
srun_pid = 0;
}
return orte_pls_base_proxy_terminate_job(jobid);
return ORTE_SUCCESS;
}
@ -439,6 +443,27 @@ static int pls_slurm_terminate_proc(const orte_process_name_t *name)
}
/**
* Signal all the processes in the child srun by sending the signal directly to it
*/
static int pls_slurm_signal_job(orte_jobid_t jobid, int32_t signal)
{
if (0 != srun_pid) {
kill(srun_pid, (int)signal);
}
return ORTE_SUCCESS;
}
/*
* Signal a specific process
*/
static int pls_slurm_signal_proc(const orte_process_name_t *name, int32_t signal)
{
return orte_pls_base_proxy_signal_proc(name, signal);
}
static int pls_slurm_finalize(void)
{
/* cleanup any pending recvs */

18
orte/mca/pls/tm/pls_tm_module.c
Просмотреть файл

@ -70,6 +70,8 @@
static int pls_tm_launch(orte_jobid_t jobid);
static int pls_tm_terminate_job(orte_jobid_t jobid);
static int pls_tm_terminate_proc(const orte_process_name_t *name);
static int pls_tm_signal_job(orte_jobid_t jobid, int32_t signal);
static int pls_tm_signal_proc(const orte_process_name_t *name, int32_t signal);
static int pls_tm_finalize(void);
static int pls_tm_connect(void);
@ -84,6 +86,8 @@ orte_pls_base_module_1_0_0_t orte_pls_tm_module = {
pls_tm_launch,
pls_tm_terminate_job,
pls_tm_terminate_proc,
pls_tm_signal_job,
pls_tm_signal_proc,
pls_tm_finalize
};
@ -449,6 +453,20 @@ pls_tm_terminate_proc(const orte_process_name_t *name)
}
static int
pls_tm_signal_job(orte_jobid_t jobid, int32_t signal)
{
return orte_pls_base_proxy_signal_job(jobid, signal);
}
static int
pls_tm_signal_proc(const orte_process_name_t *name, int32_t signal)
{
return orte_pls_base_proxy_signal_proc(name, signal);
}
/*
* Free stuff
*/

8
orte/mca/pls/xcpu/pls_xcpu.c
Просмотреть файл

@ -80,6 +80,8 @@ orte_pls_base_module_t orte_pls_xcpu_module = {
orte_pls_xcpu_launch,
orte_pls_xcpu_terminate_job,
orte_pls_xcpu_terminate_proc,
orte_pls_xcpu_signal_job,
orte_pls_xcpu_signal_proc,
orte_pls_xcpu_finalize
};
@ -328,6 +330,12 @@ int orte_pls_xcpu_terminate_job(orte_jobid_t jobid){
int orte_pls_xcpu_terminate_proc(const orte_process_name_t* proc_name){
return ORTE_SUCCESS;
}
int orte_pls_xcpu_signal_job(orte_jobid_t jobid, int32_t signal){
return ORTE_SUCCESS;
}
int orte_pls_xcpu_signal_proc(const orte_process_name_t* proc_name, int32_t signal){
return ORTE_SUCCESS;
}
int orte_pls_xcpu_finalize(void){
return ORTE_SUCCESS;
}

2
orte/mca/pls/xcpu/pls_xcpu.h
Просмотреть файл

@ -59,6 +59,8 @@ orte_pls_base_module_t* orte_pls_xcpu_init(int *priority); /* in component file
int orte_pls_xcpu_launch(orte_jobid_t);
int orte_pls_xcpu_terminate_job(orte_jobid_t);
int orte_pls_xcpu_terminate_proc(const orte_process_name_t* proc_name);
int orte_pls_xcpu_signal_job(orte_jobid_t, int32_t);
int orte_pls_xcpu_signal_proc(const orte_process_name_t* proc_name, int32_t);
int orte_pls_xcpu_finalize(void);

12
orte/mca/rmgr/base/base.h
Просмотреть файл

@ -90,6 +90,16 @@ OMPI_DECLSPEC int orte_rmgr_base_pack_terminate_proc_cmd(
orte_buffer_t* buffer,
const orte_process_name_t* name);
OMPI_DECLSPEC int orte_rmgr_base_pack_signal_job_cmd(
orte_buffer_t* buffer,
orte_jobid_t job,
int32_t signal);
OMPI_DECLSPEC int orte_rmgr_base_pack_signal_proc_cmd(
orte_buffer_t* buffer,
const orte_process_name_t* name,
int32_t signal);
OMPI_DECLSPEC int orte_rmgr_base_unpack_rsp(
orte_buffer_t* buffer);
@ -115,6 +125,8 @@ int orte_rmgr_base_map_not_available(orte_jobid_t);
int orte_rmgr_base_launch_not_available(orte_jobid_t);
int orte_rmgr_base_terminate_job_not_available(orte_jobid_t);
int orte_rmgr_base_terminate_proc_not_available(const orte_process_name_t*);
int orte_rmgr_base_signal_job_not_available(orte_jobid_t, int32_t);
int orte_rmgr_base_signal_proc_not_available(const orte_process_name_t*, int32_t);
int orte_rmgr_base_proc_stage_gate_init(orte_jobid_t job);
int orte_rmgr_base_proc_stage_gate_subscribe(orte_jobid_t job, orte_gpr_notify_cb_fn_t, void*, orte_proc_state_t);
int orte_rmgr_base_proc_stage_gate_mgr(

2
orte/mca/rmgr/base/rmgr_base_open.c
Просмотреть файл

@ -57,6 +57,8 @@ orte_rmgr_base_module_t orte_rmgr = {
orte_rmgr_base_launch_not_available,
orte_rmgr_base_terminate_job_not_available,
orte_rmgr_base_terminate_proc_not_available,
orte_rmgr_base_signal_job_not_available,
orte_rmgr_base_signal_proc_not_available,
orte_rmgr_base_spawn_not_available,
orte_rmgr_base_proc_stage_gate_init,
orte_rmgr_base_proc_stage_gate_mgr,

68
orte/mca/rmgr/base/rmgr_base_pack.c
Просмотреть файл

@ -93,7 +93,7 @@ int orte_rmgr_base_pack_terminate_proc_cmd(
{
int rc;
orte_rmgr_cmd_t cmd = ORTE_RMGR_CMD_CREATE;
orte_rmgr_cmd_t cmd = ORTE_RMGR_CMD_TERM_PROC;
OPAL_TRACE(4);
@ -112,6 +112,72 @@ int orte_rmgr_base_pack_terminate_proc_cmd(
}
int orte_rmgr_base_pack_signal_job_cmd(
orte_buffer_t* buffer,
orte_jobid_t job,
int32_t signal)
{
int rc;
orte_rmgr_cmd_t cmd = ORTE_RMGR_CMD_SIGNAL_JOB;
OPAL_TRACE(4);
rc = orte_dss.pack(buffer, &cmd, 1, ORTE_RMGR_CMD);
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
rc = orte_dss.pack(buffer, &job, 1, ORTE_JOBID);
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
rc = orte_dss.pack(buffer, (void*)&signal, 1, ORTE_INT32);
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
return ORTE_SUCCESS;
}
int orte_rmgr_base_pack_signal_proc_cmd(
orte_buffer_t* buffer,
const orte_process_name_t* name,
int32_t signal)
{
int rc;
orte_rmgr_cmd_t cmd = ORTE_RMGR_CMD_SIGNAL_PROC;
OPAL_TRACE(4);
rc = orte_dss.pack(buffer, &cmd, 1, ORTE_RMGR_CMD);
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
rc = orte_dss.pack(buffer, (void*)name, 1, ORTE_NAME);
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
rc = orte_dss.pack(buffer, (void*)&signal, 1, ORTE_INT32);
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
return rc;
}
return ORTE_SUCCESS;
}
int orte_rmgr_base_unpack_rsp(
orte_buffer_t* buffer)
{

12
orte/mca/rmgr/base/rmgr_base_stubs.c
Просмотреть файл

@ -80,6 +80,18 @@ orte_rmgr_base_terminate_proc_not_available(const orte_process_name_t* proc_name
return ORTE_ERR_UNREACH;
}
int
orte_rmgr_base_signal_job_not_available(orte_jobid_t jobid, int32_t signal)
{
return ORTE_ERR_UNREACH;
}
int
orte_rmgr_base_signal_proc_not_available(const orte_process_name_t* proc_name, int32_t signal)
{
return ORTE_ERR_UNREACH;
}
int
orte_rmgr_base_spawn_not_available(
orte_app_context_t** app_context,

52
orte/mca/rmgr/base/rmgr_base_unpack.c
Просмотреть файл

@ -188,6 +188,54 @@ static int orte_rmgr_base_cmd_term_proc(orte_buffer_t* req, orte_buffer_t* rsp)
}
static int orte_rmgr_base_cmd_signal_job(orte_buffer_t* req, orte_buffer_t* rsp)
{
int rc;
orte_jobid_t jobid;
size_t cnt = 1;
int32_t signal;
OPAL_TRACE(4);
if(ORTE_SUCCESS != (rc = orte_dss.unpack(req, &jobid, &cnt, ORTE_JOBID))) {
ORTE_ERROR_LOG(rc);
return rc;
}
if(ORTE_SUCCESS != (rc = orte_dss.unpack(req, &signal, &cnt, ORTE_INT32))) {
ORTE_ERROR_LOG(rc);
return rc;
}
rc = orte_rmgr.signal_job(jobid, signal);
return orte_dss.pack(rsp, &rc, 1, ORTE_INT32);
}
static int orte_rmgr_base_cmd_signal_proc(orte_buffer_t* req, orte_buffer_t* rsp)
{
int rc;
orte_process_name_t name;
size_t cnt = 1;
int32_t signal;
OPAL_TRACE(4);
if(ORTE_SUCCESS != (rc = orte_dss.unpack(req, &name, &cnt, ORTE_NAME))) {
ORTE_ERROR_LOG(rc);
}
if(ORTE_SUCCESS != (rc = orte_dss.unpack(req, &signal, &cnt, ORTE_INT32))) {
ORTE_ERROR_LOG(rc);
return rc;
}
rc = orte_rmgr.signal_proc(&name, signal);
return orte_dss.pack(rsp, &rc, 1, ORTE_INT32);
}
int orte_rmgr_base_cmd_dispatch(orte_buffer_t* req, orte_buffer_t* rsp)
{
@ -220,6 +268,10 @@ int orte_rmgr_base_cmd_dispatch(orte_buffer_t* req, orte_buffer_t* rsp)
return orte_rmgr_base_cmd_term_job(req,rsp);
case ORTE_RMGR_CMD_TERM_PROC:
return orte_rmgr_base_cmd_term_proc(req,rsp);
case ORTE_RMGR_CMD_SIGNAL_JOB:
return orte_rmgr_base_cmd_signal_job(req,rsp);
case ORTE_RMGR_CMD_SIGNAL_PROC:
return orte_rmgr_base_cmd_signal_proc(req,rsp);
default:
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
return ORTE_ERR_BAD_PARAM;

19
orte/mca/rmgr/cnos/rmgr_cnos.c
Просмотреть файл

@ -62,6 +62,12 @@ static int orte_rmgr_cnos_terminate_job(
static int orte_rmgr_cnos_terminate_proc(
const orte_process_name_t* proc_name);
static int orte_rmgr_cnos_signal_job(
orte_jobid_t jobid);
static int orte_rmgr_cnos_signal_proc(
const orte_process_name_t* proc_name);
static int orte_rmgr_cnos_spawn(
orte_app_context_t** app_context,
size_t num_context,
@ -80,6 +86,8 @@ orte_rmgr_base_module_t orte_rmgr_cnos_module = {
orte_rmgr_cnos_launch,
orte_rmgr_cnos_terminate_job,
orte_rmgr_cnos_terminate_proc,
orte_rmgr_cnos_signal_job,
orte_rmgr_cnos_signal_proc,
orte_rmgr_cnos_spawn,
orte_rmgr_base_proc_stage_gate_init,
orte_rmgr_base_proc_stage_gate_mgr,
@ -177,6 +185,17 @@ static int orte_rmgr_cnos_terminate_proc(const orte_process_name_t* proc_name)
}
static int orte_rmgr_cnos_signal_job(orte_jobid_t jobid)
{
return ORTE_ERR_NOT_SUPPORTED;
}
static int orte_rmgr_cnos_signal_proc(const orte_process_name_t* proc_name)
{
return ORTE_ERR_NOT_SUPPORTED;
}
static int orte_rmgr_cnos_spawn(
orte_app_context_t** app_context,
size_t num_context,

93
orte/mca/rmgr/proxy/rmgr_proxy.c
Просмотреть файл

@ -59,6 +59,13 @@ static int orte_rmgr_proxy_terminate_job(
static int orte_rmgr_proxy_terminate_proc(
const orte_process_name_t* proc_name);
static int orte_rmgr_proxy_signal_job(
orte_jobid_t jobid, int32_t signal);
static int orte_rmgr_proxy_signal_proc(
const orte_process_name_t* proc_name,
int32_t signal);
static int orte_rmgr_proxy_spawn(
orte_app_context_t** app_context,
size_t num_context,
@ -75,6 +82,8 @@ orte_rmgr_base_module_t orte_rmgr_proxy_module = {
orte_rmgr_proxy_launch,
orte_rmgr_proxy_terminate_job,
orte_rmgr_proxy_terminate_proc,
orte_rmgr_proxy_signal_job,
orte_rmgr_proxy_signal_proc,
orte_rmgr_proxy_spawn,
orte_rmgr_base_proc_stage_gate_init,
orte_rmgr_base_proc_stage_gate_mgr,
@ -260,6 +269,90 @@ static int orte_rmgr_proxy_terminate_proc(const orte_process_name_t* proc_name)
return ORTE_SUCCESS;
}
static int orte_rmgr_proxy_signal_job(orte_jobid_t jobid, int32_t signal)
{
orte_buffer_t cmd;
orte_buffer_t rsp;
int rc;
OPAL_TRACE(1);
/* construct command */
OBJ_CONSTRUCT(&cmd, orte_buffer_t);
rc = orte_rmgr_base_pack_signal_job_cmd(&cmd, jobid, signal);
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&cmd);
return rc;
}
if(0 > (rc = orte_rml.send_buffer(ORTE_RML_NAME_SEED, &cmd, ORTE_RML_TAG_RMGR_SVC, 0))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&cmd);
return rc;
}
OBJ_DESTRUCT(&cmd);
/* wait for response */
OBJ_CONSTRUCT(&rsp, orte_buffer_t);
if(0 > (rc = orte_rml.recv_buffer(ORTE_RML_NAME_SEED, &rsp, ORTE_RML_TAG_RMGR_CLNT))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&rsp);
return rc;
}
rc = orte_rmgr_base_unpack_rsp(&rsp);
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&rsp);
return rc;
}
OBJ_DESTRUCT(&rsp);
return ORTE_SUCCESS;
}
static int orte_rmgr_proxy_signal_proc(const orte_process_name_t* proc_name, int32_t signal)
{
orte_buffer_t cmd;
orte_buffer_t rsp;
int rc;
OPAL_TRACE(1);
/* construct command */
OBJ_CONSTRUCT(&cmd, orte_buffer_t);
rc = orte_rmgr_base_pack_signal_proc_cmd(&cmd, proc_name, signal);
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&cmd);
return rc;
}
if(0 > (rc = orte_rml.send_buffer(ORTE_RML_NAME_SEED, &cmd, ORTE_RML_TAG_RMGR_SVC, 0))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&cmd);
return rc;
}
OBJ_DESTRUCT(&cmd);
/* wait for response */
OBJ_CONSTRUCT(&rsp, orte_buffer_t);
if(0 > (rc = orte_rml.recv_buffer(ORTE_RML_NAME_SEED, &rsp, ORTE_RML_TAG_RMGR_CLNT))) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&rsp);
return rc;
}
rc = orte_rmgr_base_unpack_rsp(&rsp);
if(ORTE_SUCCESS != rc) {
ORTE_ERROR_LOG(rc);
OBJ_DESTRUCT(&rsp);
return rc;
}
OBJ_DESTRUCT(&rsp);
return ORTE_SUCCESS;
}
static void orte_rmgr_proxy_wireup_stdin(orte_jobid_t jobid)
{
int rc;

14
orte/mca/rmgr/rmgr.h
Просмотреть файл

@ -126,6 +126,18 @@ typedef int (*orte_rmgr_base_module_terminate_job_fn_t)(orte_jobid_t job);
*/
typedef int (*orte_rmgr_base_module_terminate_proc_fn_t)(const orte_process_name_t* proc_name);
/**
* Transmit a signal to an entire job
*/
typedef int (*orte_rmgr_base_module_signal_job_fn_t)(orte_jobid_t job, int32_t signal);
/**
* Transmit a signal to a specific process
*/
typedef int (*orte_rmgr_base_module_signal_proc_fn_t)(const orte_process_name_t* proc_name, int32_t signal);
/*
* Callback function for resource manager
*/
@ -193,6 +205,8 @@ struct orte_rmgr_base_module_1_0_0_t {
orte_rmgr_base_module_launch_fn_t launch;
orte_rmgr_base_module_terminate_job_fn_t terminate_job;
orte_rmgr_base_module_terminate_proc_fn_t terminate_proc;
orte_rmgr_base_module_signal_job_fn_t signal_job;
orte_rmgr_base_module_signal_proc_fn_t signal_proc;
orte_rmgr_base_module_spawn_fn_t spawn;
orte_rmgr_base_module_proc_stage_gate_init_fn_t stage_gate_init;
orte_rmgr_base_module_proc_stage_gate_mgr_fn_t stage_gate_mgr;

20
orte/mca/rmgr/rmgr_types.h
Просмотреть файл

@ -31,15 +31,17 @@ extern "C" {
/*
* Constants for command values
*/
#define ORTE_RMGR_CMD_QUERY 1
#define ORTE_RMGR_CMD_CREATE 2
#define ORTE_RMGR_CMD_ALLOCATE 3
#define ORTE_RMGR_CMD_DEALLOCATE 4
#define ORTE_RMGR_CMD_MAP 5
#define ORTE_RMGR_CMD_LAUNCH 6
#define ORTE_RMGR_CMD_TERM_JOB 7
#define ORTE_RMGR_CMD_TERM_PROC 8
#define ORTE_RMGR_CMD_SPAWN 9
#define ORTE_RMGR_CMD_QUERY 1
#define ORTE_RMGR_CMD_CREATE 2
#define ORTE_RMGR_CMD_ALLOCATE 3
#define ORTE_RMGR_CMD_DEALLOCATE 4
#define ORTE_RMGR_CMD_MAP 5
#define ORTE_RMGR_CMD_LAUNCH 6
#define ORTE_RMGR_CMD_TERM_JOB 7
#define ORTE_RMGR_CMD_TERM_PROC 8
#define ORTE_RMGR_CMD_SPAWN 9
#define ORTE_RMGR_CMD_SIGNAL_JOB 10
#define ORTE_RMGR_CMD_SIGNAL_PROC 11
#define ORTE_RMGR_CMD ORTE_UINT32
typedef uint32_t orte_rmgr_cmd_t;

48
orte/mca/rmgr/urm/rmgr_urm.c
Просмотреть файл

@ -70,6 +70,13 @@ static int orte_rmgr_urm_terminate_job(
static int orte_rmgr_urm_terminate_proc(
const orte_process_name_t* proc_name);
static int orte_rmgr_urm_signal_job(
orte_jobid_t jobid, int32_t signal);
static int orte_rmgr_urm_signal_proc(
const orte_process_name_t* proc_name,
int32_t signal);
static int orte_rmgr_urm_spawn(
orte_app_context_t** app_context,
size_t num_context,
@ -89,6 +96,8 @@ orte_rmgr_base_module_t orte_rmgr_urm_module = {
orte_rmgr_urm_launch,
orte_rmgr_urm_terminate_job,
orte_rmgr_urm_terminate_proc,
orte_rmgr_urm_signal_job,
orte_rmgr_urm_signal_proc,
orte_rmgr_urm_spawn,
orte_rmgr_base_proc_stage_gate_init,
orte_rmgr_base_proc_stage_gate_mgr,
@ -230,6 +239,45 @@ static int orte_rmgr_urm_terminate_proc(const orte_process_name_t* proc_name)
}
static int orte_rmgr_urm_signal_job(orte_jobid_t jobid, int32_t signal)
{
int ret;
orte_jobid_t my_jobid;
OPAL_TRACE(1);
ret = orte_ns.get_jobid(&my_jobid, orte_process_info.my_name);
if (ORTE_SUCCESS == ret) {
/** if our jobid is the one we're trying to signal AND we're a
* singleton, then calling the urm_pls isn't going to be able
* to do anything - we already have the signal! */
if (orte_process_info.singleton && jobid == my_jobid) {
return ORTE_SUCCESS;
}
}
return mca_rmgr_urm_component.urm_pls->signal_job(jobid, signal);
}
static int orte_rmgr_urm_signal_proc(const orte_process_name_t* proc_name, int32_t signal)
{
OPAL_TRACE(1);
if ((0 == orte_ns.compare(ORTE_NS_CMP_ALL, proc_name,
orte_process_info.my_name)) &&
(orte_process_info.singleton)) {
/** if we're trying to signal ourselves and we're a
* singleton, calling signal_proc isn't going to work
* properly -- there's no pls setup properly for us. Besides, we
* already have the signal!
*/
return ORTE_SUCCESS;
}
return mca_rmgr_urm_component.urm_pls->signal_proc(proc_name, signal);
}
static void orte_rmgr_urm_wireup_stdin(orte_jobid_t jobid)
{
int rc;

14
orte/test/system/Makefile Обычный файл
Просмотреть файл

@ -0,0 +1,14 @@
PROGS = no_op mpi_no_op hello hello_null sigusr_trap
all: $(PROGS)
CC = mpicc
CFLAGS = -g
CXX = mpic++
CXXFLAGS = -g
F77 = mpif77
FC = mpif77
FFLAGS = -g
clean:
rm -f $(PROGS) *~

23
orte/test/system/hello.c Обычный файл
Просмотреть файл

@ -0,0 +1,23 @@
/* -*- C -*-
*
* $HEADER$
*
* The most basic of MPI applications
*/
#include <stdio.h>
#include "mpi.h"
int main(int argc, char* argv[])
{
int rank, size;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
printf("Hello, World, I am %d of %d\n", rank, size);
MPI_Finalize();
return 0;
}

23
orte/test/system/hello_null.c Обычный файл
Просмотреть файл

@ -0,0 +1,23 @@
/* -*- C -*-
*
* $HEADER$
*
* The most basic of MPI applications
*/
#include <stdio.h>
#include "mpi.h"
int main(int argc, char* argv[])
{
int rank, size;
MPI_Init(NULL, NULL);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
printf("Hello, World, I am %d of %d\n", rank, size);
MPI_Finalize();
return 0;
}

17
orte/test/system/mpi_no_op.c Обычный файл
Просмотреть файл

@ -0,0 +1,17 @@
/* -*- C -*-
*
* $HEADER$
*
* The most basic of MPI applications
*/
#include <stdio.h>
#include "mpi.h"
int main(int argc, char* argv[])
{
MPI_Init(&argc, &argv);
MPI_Finalize();
return 0;
}

13
orte/test/system/no_op.c Обычный файл
Просмотреть файл

@ -0,0 +1,13 @@
/* -*- C -*-
*
* $HEADER$
*
* The most basic of applications
*/
#include <stdio.h>
int main(int argc, char* argv[])
{
return 0;
}

87
orte/test/system/sigusr_trap.c Обычный файл
Просмотреть файл

@ -0,0 +1,87 @@
/* -*- C -*-
*
* $HEADER$
*
* A test to trap user signals
*/
#include <stdio.h>
#include <signal.h>
#include "orte/runtime/runtime.h"
void sigusr_handler(int signum)
{
switch (signum) {
case SIGUSR1:
fprintf(stderr, "Trapped SIGUSR1\n");
break;
case SIGUSR2:
fprintf(stderr, "Trapped SIGUSR2\n");
return;
default:
fprintf(stderr, "Undefined signal %d trapped\n", signum);
return;
}
}
void exit_handler(int signum)
{
int rc;
if (ORTE_SUCCESS != (rc = orte_finalize())) {
fprintf(stderr, "couldn't complete finalize - error code %d\n", rc);
exit(1);
}
exit(0);
}
int main(int argc, char* argv[])
{
int rc;
int i;
double pi;
if (signal(SIGUSR1, sigusr_handler) == SIG_IGN) {
fprintf(stderr, "Could not setup signal trap for SIGUSR1\n");
exit(1);
}
if (signal(SIGUSR2, sigusr_handler) == SIG_IGN) {
fprintf(stderr, "Could not setup signal trap for SIGUSR2\n");
exit(1);
}
if (signal(SIGINT, exit_handler) == SIG_IGN) {
fprintf(stderr, "Could not setup signal trap for SIGINT\n");
exit(1);
}
if (signal(SIGHUP, exit_handler) == SIG_IGN) {
fprintf(stderr, "Could not setup signal trap for SIGHUP\n");
exit(1);
}
if (signal(SIGTERM, exit_handler) == SIG_IGN) {
fprintf(stderr, "Could not setup signal trap for SIGTERM\n");
exit(1);
}
if (ORTE_SUCCESS != (rc = orte_init(true))) {
fprintf(stderr, "couldn't complete init - error code %d\n", rc);
exit(1);
}
i = 0;
while (1) {
i++;
pi = i / 3.14159256;
if (i > 100) i = 0;
}
return 0;
}

82
orte/tools/orterun/orterun.c
Просмотреть файл

@ -80,11 +80,17 @@ extern char** environ;
*/
static struct opal_event term_handler;
static struct opal_event int_handler;
static struct opal_event sigusr1_handler;
static struct opal_event sigusr2_handler;
static orte_jobid_t jobid = ORTE_JOBID_MAX;
static orte_pointer_array_t *apps_pa;
static bool wait_for_job_completion = true;
static char *abort_msg = NULL;
static size_t abort_msg_len = 0;
static char *sigusr1_msg = NULL;
static size_t sigusr1_msg_len = 0;
static char *sigusr2_msg = NULL;
static size_t sigusr2_msg_len = 0;
static char *orterun_basename = NULL;
static int max_display_aborted = 1;
static int num_aborted = 0;
@ -245,7 +251,9 @@ opal_cmd_line_init_t cmd_line_init[] = {
* Local functions
*/
static void exit_callback(int fd, short event, void *arg);
static void signal_callback(int fd, short flags, void *arg);
static void abort_signal_callback(int fd, short flags, void *arg);
static void sigusr1_callback(int fd, short flags, void *arg);
static void sigusr2_callback(int fd, short flags, void *arg);
static int create_app(int argc, char* argv[], orte_app_context_t **app,
bool *made_app, char ***app_env);
static int init_globals(void);
@ -273,6 +281,12 @@ int orterun(int argc, char *argv[])
asprintf(&abort_msg, "%s: killing job...\n", orterun_basename);
abort_msg_len = strlen(abort_msg);
/** Setup the user signal message (for use in the signal handler) */
asprintf(&sigusr1_msg, "%s: received SIGUSR1 signal\n", orterun_basename);
sigusr1_msg_len = strlen(sigusr1_msg);
asprintf(&sigusr2_msg, "%s: received SIGUSR2 signal\n", orterun_basename);
sigusr2_msg_len = strlen(sigusr2_msg);
/* Check for some "global" command line params */
parse_globals(argc, argv);
@ -389,13 +403,22 @@ int orterun(int argc, char *argv[])
/* Prep to start the application */
/** setup callbacks for abort signals */
opal_signal_set(&term_handler, SIGTERM,
signal_callback, NULL);
abort_signal_callback, NULL);
opal_signal_add(&term_handler, NULL);
opal_signal_set(&int_handler, SIGINT,
signal_callback, NULL);
abort_signal_callback, NULL);
opal_signal_add(&int_handler, NULL);
/** setup callbacks for user signals */
opal_signal_set(&sigusr1_handler, SIGUSR1,
sigusr1_callback, NULL);
opal_signal_add(&sigusr1_handler, NULL);
opal_signal_set(&sigusr2_handler, SIGUSR2,
sigusr2_callback, NULL);
opal_signal_add(&sigusr2_handler, NULL);
orte_totalview_init_before_spawn();
/* Spawn the job */
@ -661,6 +684,10 @@ static void exit_callback(int fd, short event, void *arg)
opal_signal_del(&term_handler);
opal_signal_del(&int_handler);
/** Remove the USR signal handlers */
opal_signal_del(&sigusr1_handler);
opal_signal_del(&sigusr2_handler);
/* Trigger the normal exit conditions */
orterun_globals.exit = true;
@ -674,7 +701,7 @@ static void exit_callback(int fd, short event, void *arg)
* the job has been aborted.
*/
static void signal_callback(int fd, short flags, void *arg)
static void abort_signal_callback(int fd, short flags, void *arg)
{
int ret;
struct timeval tv = { 5, 0 };
@ -703,6 +730,53 @@ static void signal_callback(int fd, short flags, void *arg)
}
/**
* Pass user signals to the remote application processes
*/
static void sigusr1_callback(int fd, short flags, void *arg)
{
int ret;
static int signalled = 0;
OPAL_TRACE(1);
if (0 != signalled++) { /** protect against multiple entry */
return;
}
write (2, sigusr1_msg, sigusr1_msg_len);
/** send the signal out to the processes */
if (ORTE_SUCCESS != (ret = orte_rmgr.signal_job(jobid, SIGUSR1))) {
fprintf(stderr, "SIGUSR1 could not be sent to the job\n");
}
}
static void sigusr2_callback(int fd, short flags, void *arg)
{
int ret;
static int signalled = 0;
OPAL_TRACE(1);
if (0 != signalled++) { /** protect against multiple entry */
return;
}
write (2, sigusr2_msg, sigusr2_msg_len);
/** send the signal out to the processes */
if (ORTE_SUCCESS != (ret = orte_rmgr.signal_job(jobid, SIGUSR2))) {
fprintf(stderr, "SIGUSR2 could not be sent to the job\n");
}
}
static int init_globals(void)
{
struct globals_t tmp = {