本文整理汇总了C++中slurm_set_addr函数的典型用法代码示例。如果您正苦于以下问题：C++ slurm_set_addr函数的具体用法？C++ slurm_set_addr怎么用？C++ slurm_set_addr使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了slurm_set_addr函数的20个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于我们的系统推荐出更棒的C++代码示例。
示例1: srun_node_fail
/*
* srun_node_fail - notify srun of a node's failure
* IN job_ptr - job to notify
* IN node_name - name of failed node
*/
extern void srun_node_fail(struct job_record *job_ptr, char *node_name)
{
#ifndef HAVE_FRONT_END
struct node_record *node_ptr;
#endif
int bit_position = -1;
slurm_addr_t * addr;
srun_node_fail_msg_t *msg_arg;
ListIterator step_iterator;
struct step_record *step_ptr;
xassert(job_ptr);
xassert(node_name);
if (!job_ptr || !IS_JOB_RUNNING(job_ptr))
return;
#ifdef HAVE_FRONT_END
/* Purge all jobs steps in front end mode */
#else
if (!node_name || (node_ptr = find_node_record(node_name)) == NULL)
return;
bit_position = node_ptr - node_record_table_ptr;
#endif
step_iterator = list_iterator_create(job_ptr->step_list);
while ((step_ptr = (struct step_record *) list_next(step_iterator))) {
if (step_ptr->step_node_bitmap == NULL) /* pending step */
continue;
if ((bit_position >= 0) &&
(!bit_test(step_ptr->step_node_bitmap, bit_position)))
continue; /* job step not on this node */
if ( (step_ptr->port == 0) ||
(step_ptr->host == NULL) ||
(step_ptr->batch_step) ||
(step_ptr->host[0] == '\0') )
continue;
addr = xmalloc(sizeof(struct sockaddr_in));
slurm_set_addr(addr, step_ptr->port, step_ptr->host);
msg_arg = xmalloc(sizeof(srun_node_fail_msg_t));
msg_arg->job_id = job_ptr->job_id;
msg_arg->step_id = step_ptr->step_id;
msg_arg->nodelist = xstrdup(node_name);
_srun_agent_launch(addr, step_ptr->host, SRUN_NODE_FAIL,
msg_arg, step_ptr->start_protocol_ver);
}
list_iterator_destroy(step_iterator);
if (job_ptr->other_port && job_ptr->alloc_node && job_ptr->resp_host) {
addr = xmalloc(sizeof(struct sockaddr_in));
slurm_set_addr(addr, job_ptr->other_port, job_ptr->resp_host);
msg_arg = xmalloc(sizeof(srun_node_fail_msg_t));
msg_arg->job_id = job_ptr->job_id;
msg_arg->step_id = NO_VAL;
msg_arg->nodelist = xstrdup(node_name);
_srun_agent_launch(addr, job_ptr->alloc_node, SRUN_NODE_FAIL,
msg_arg, job_ptr->start_protocol_ver);
}
}
开发者ID:chrisdukey，项目名称:slurm，代码行数:63，代码来源:srun_comm.c
示例2: srun_allocate
/*
* srun_allocate - notify srun of a resource allocation
* IN job_ptr - job allocated resources
*/
extern void srun_allocate(struct job_record *job_ptr)
{
struct job_record *pack_job, *pack_leader;
resource_allocation_response_msg_t *msg_arg = NULL;
slurm_addr_t *addr;
ListIterator iter;
List job_resp_list = NULL;
xassert(job_ptr);
if (!job_ptr || !job_ptr->alloc_resp_port || !job_ptr->alloc_node ||
!job_ptr->resp_host || !job_ptr->job_resrcs ||
!job_ptr->job_resrcs->cpu_array_cnt)
return;
if (job_ptr->pack_job_id == 0) {
addr = xmalloc(sizeof(struct sockaddr_in));
slurm_set_addr(addr, job_ptr->alloc_resp_port,
job_ptr->resp_host);
msg_arg = build_alloc_msg(job_ptr, SLURM_SUCCESS, NULL);
_srun_agent_launch(addr, job_ptr->alloc_node,
RESPONSE_RESOURCE_ALLOCATION, msg_arg,
job_ptr->start_protocol_ver);
} else if (_pending_pack_jobs(job_ptr)) {
return;
} else if ((pack_leader = find_job_record(job_ptr->pack_job_id))) {
addr = xmalloc(sizeof(struct sockaddr_in));
slurm_set_addr(addr, pack_leader->alloc_resp_port,
pack_leader->resp_host);
job_resp_list = list_create(_free_srun_alloc);
iter = list_iterator_create(pack_leader->pack_job_list);
while ((pack_job = (struct job_record *) list_next(iter))) {
if (pack_leader->pack_job_id != pack_job->pack_job_id) {
error("%s: Bad pack_job_list for %pJ",
__func__, pack_leader);
continue;
}
msg_arg = build_alloc_msg(pack_job, SLURM_SUCCESS,
NULL);
list_append(job_resp_list, msg_arg);
msg_arg = NULL;
}
list_iterator_destroy(iter);
_srun_agent_launch(addr, job_ptr->alloc_node,
RESPONSE_JOB_PACK_ALLOCATION, job_resp_list,
job_ptr->start_protocol_ver);
} else {
error("%s: Can not find pack job leader %pJ",
__func__, job_ptr);
}
}
开发者ID:chrisdukey，项目名称:slurm，代码行数:55，代码来源:srun_comm.c
示例3: srun_timeout
/*
* srun_timeout - notify srun of a job's imminent timeout
* IN job_ptr - pointer to the slurmctld job record
*/
extern void srun_timeout (struct job_record *job_ptr)
{
slurm_addr_t * addr;
srun_timeout_msg_t *msg_arg;
ListIterator step_iterator;
struct step_record *step_ptr;
xassert(job_ptr);
if (!IS_JOB_RUNNING(job_ptr))
return;
if (job_ptr->other_port && job_ptr->alloc_node && job_ptr->resp_host) {
addr = xmalloc(sizeof(struct sockaddr_in));
slurm_set_addr(addr, job_ptr->other_port, job_ptr->resp_host);
msg_arg = xmalloc(sizeof(srun_timeout_msg_t));
msg_arg->job_id = job_ptr->job_id;
msg_arg->step_id = NO_VAL;
msg_arg->timeout = job_ptr->end_time;
_srun_agent_launch(addr, job_ptr->alloc_node, SRUN_TIMEOUT,
msg_arg, job_ptr->start_protocol_ver);
}
step_iterator = list_iterator_create(job_ptr->step_list);
while ((step_ptr = (struct step_record *) list_next(step_iterator)))
srun_step_timeout(step_ptr, job_ptr->end_time);
list_iterator_destroy(step_iterator);
}
开发者ID:chrisdukey，项目名称:slurm，代码行数:32，代码来源:srun_comm.c
示例4: msg_aggr_sender_init
extern void msg_aggr_sender_init(char *host, uint16_t port, uint64_t window,
uint64_t max_msg_cnt)
{
if (msg_collection.running || (max_msg_cnt <= 1))
return;
memset(&msg_collection, 0, sizeof(msg_collection_type_t));
slurm_mutex_init(&msg_collection.aggr_mutex);
slurm_mutex_init(&msg_collection.mutex);
slurm_mutex_lock(&msg_collection.mutex);
slurm_mutex_lock(&msg_collection.aggr_mutex);
slurm_cond_init(&msg_collection.cond, NULL);
slurm_set_addr(&msg_collection.node_addr, port, host);
msg_collection.window = window;
msg_collection.max_msg_cnt = max_msg_cnt;
msg_collection.msg_aggr_list = list_create(_msg_aggr_free);
msg_collection.msg_list = list_create(slurm_free_comp_msg_list);
msg_collection.max_msgs = false;
msg_collection.debug_flags = slurm_get_debug_flags();
slurm_mutex_unlock(&msg_collection.aggr_mutex);
slurm_mutex_unlock(&msg_collection.mutex);
slurm_thread_create(&msg_collection.thread_id,
&_msg_aggregation_sender, NULL);
}
开发者ID:supermanue，项目名称:slurm，代码行数:27，代码来源:msg_aggr.c
示例5: _ping_controller
/* Ping primary ControlMachine
* RET 0 if no error */
static int _ping_controller(void)
{
int rc;
slurm_msg_t req;
/* Locks: Read configuration */
slurmctld_lock_t config_read_lock = {
READ_LOCK, NO_LOCK, NO_LOCK, NO_LOCK };
/*
* Set address of controller to ping
*/
slurm_msg_t_init(&req);
lock_slurmctld(config_read_lock);
debug3("pinging slurmctld at %s", slurmctld_conf.control_addr);
slurm_set_addr(&req.address, slurmctld_conf.slurmctld_port,
slurmctld_conf.control_addr);
unlock_slurmctld(config_read_lock);
req.msg_type = REQUEST_PING;
if (slurm_send_recv_rc_msg_only_one(&req, &rc, 0) < 0) {
error("_ping_controller/slurm_send_node_msg error: %m");
return SLURM_ERROR;
}
if (rc) {
error("_ping_controller/response error %d", rc);
return SLURM_PROTOCOL_ERROR;
}
return SLURM_PROTOCOL_SUCCESS;
}
开发者ID:bingzhang，项目名称:slurm，代码行数:34，代码来源:backup.c
示例6: srun_job_complete
/*
* srun_job_complete - notify srun of a job's termination
* IN job_ptr - pointer to the slurmctld job record
*/
extern void srun_job_complete (struct job_record *job_ptr)
{
slurm_addr_t * addr;
srun_job_complete_msg_t *msg_arg;
ListIterator step_iterator;
struct step_record *step_ptr;
xassert(job_ptr);
if (job_ptr->other_port && job_ptr->alloc_node && job_ptr->resp_host) {
addr = xmalloc(sizeof(struct sockaddr_in));
slurm_set_addr(addr, job_ptr->other_port, job_ptr->resp_host);
msg_arg = xmalloc(sizeof(srun_job_complete_msg_t));
msg_arg->job_id = job_ptr->job_id;
msg_arg->step_id = NO_VAL;
_srun_agent_launch(addr, job_ptr->alloc_node,
SRUN_JOB_COMPLETE, msg_arg);
}
step_iterator = list_iterator_create(job_ptr->step_list);
while ((step_ptr = (struct step_record *) list_next(step_iterator))) {
if (step_ptr->batch_step) /* batch script itself */
continue;
srun_step_complete(step_ptr);
}
list_iterator_destroy(step_iterator);
}
开发者ID:Xarthisius，项目名称:slurm，代码行数:31，代码来源:srun_comm.c
示例7: srun_ping
/* srun_ping - ping all srun commands that have not been heard from recently */
extern void srun_ping (void)
{
ListIterator job_iterator;
struct job_record *job_ptr;
slurm_addr_t * addr;
time_t now = time(NULL);
time_t old = now - (slurmctld_conf.inactive_limit / 3) +
slurmctld_conf.msg_timeout + 1;
srun_ping_msg_t *msg_arg;
if (slurmctld_conf.inactive_limit == 0)
return; /* No limit, don't bother pinging */
job_iterator = list_iterator_create(job_list);
while ((job_ptr = (struct job_record *) list_next(job_iterator))) {
xassert (job_ptr->magic == JOB_MAGIC);
if (!IS_JOB_RUNNING(job_ptr))
continue;
if ((job_ptr->time_last_active <= old) && job_ptr->other_port
&& job_ptr->alloc_node && job_ptr->resp_host) {
addr = xmalloc(sizeof(struct sockaddr_in));
slurm_set_addr(addr, job_ptr->other_port,
job_ptr->resp_host);
msg_arg = xmalloc(sizeof(srun_ping_msg_t));
msg_arg->job_id = job_ptr->job_id;
msg_arg->step_id = NO_VAL;
_srun_agent_launch(addr, job_ptr->alloc_node,
SRUN_PING, msg_arg);
}
}
list_iterator_destroy(job_iterator);
}
开发者ID:Xarthisius，项目名称:slurm，代码行数:36，代码来源:srun_comm.c
示例8: _forward_comm_set
/* Forward keypair info to other tasks as required.
* Clear message forward structure upon completion.
* The messages are forwarded sequentially. */
static int _forward_comm_set(struct kvs_comm_set *kvs_set_ptr)
{
int i, rc = SLURM_SUCCESS;
int tmp_host_cnt = kvs_set_ptr->host_cnt;
slurm_msg_t msg_send;
int msg_rc;
kvs_set_ptr->host_cnt = 0;
for (i=0; i<tmp_host_cnt; i++) {
if (kvs_set_ptr->kvs_host_ptr[i].port == 0)
continue; /* empty */
slurm_msg_t_init(&msg_send);
msg_send.msg_type = PMI_KVS_GET_RESP;
msg_send.data = (void *) kvs_set_ptr;
slurm_set_addr(&msg_send.address,
kvs_set_ptr->kvs_host_ptr[i].port,
kvs_set_ptr->kvs_host_ptr[i].hostname);
if (slurm_send_recv_rc_msg_only_one(&msg_send,
&msg_rc, 0) < 0) {
error("Could not forward msg to %s",
kvs_set_ptr->kvs_host_ptr[i].hostname);
msg_rc = 1;
}
rc = MAX(rc, msg_rc);
xfree(kvs_set_ptr->kvs_host_ptr[i].hostname);
}
xfree(kvs_set_ptr->kvs_host_ptr);
return rc;
}
开发者ID:mart1nl，项目名称:slurm，代码行数:32，代码来源:slurm_pmi.c
示例9: srun_exec
/*
* srun_exec - request that srun execute a specific command
* and route it's output to stdout
* IN step_ptr - pointer to the slurmctld job step record
* IN argv - command and arguments to execute
*/
extern void srun_exec(struct step_record *step_ptr, char **argv)
{
slurm_addr_t * addr;
srun_exec_msg_t *msg_arg;
int cnt = 1, i;
xassert(step_ptr);
if (step_ptr->port && step_ptr->host && step_ptr->host[0]) {
for (i=0; argv[i]; i++)
cnt++; /* start at 1 to include trailing NULL */
addr = xmalloc(sizeof(struct sockaddr_in));
slurm_set_addr(addr, step_ptr->port, step_ptr->host);
msg_arg = xmalloc(sizeof(srun_exec_msg_t));
msg_arg->job_id = step_ptr->job_ptr->job_id;
msg_arg->step_id = step_ptr->step_id;
msg_arg->argc = cnt;
msg_arg->argv = xmalloc(sizeof(char *) * cnt);
for (i=0; i<cnt ; i++)
msg_arg->argv[i] = xstrdup(argv[i]);
_srun_agent_launch(addr, step_ptr->host, SRUN_EXEC,
msg_arg);
} else {
error("srun_exec %u.%u lacks communication channel",
step_ptr->job_ptr->job_id, step_ptr->step_id);
}
}
开发者ID:Xarthisius，项目名称:slurm，代码行数:33，代码来源:srun_comm.c
示例10: slurm_setup_remote_working_cluster
extern void
slurm_setup_remote_working_cluster(resource_allocation_response_msg_t *msg)
{
xassert(msg);
xassert(msg->working_cluster_rec);
xassert(msg->node_list);
xassert(msg->node_addr);
if (working_cluster_rec)
slurmdb_destroy_cluster_rec(working_cluster_rec);
working_cluster_rec = (slurmdb_cluster_rec_t *)msg->working_cluster_rec;
msg->working_cluster_rec = NULL;
working_cluster_rec->plugin_id_select =
select_get_plugin_id_pos(working_cluster_rec->plugin_id_select);
slurm_set_addr(&working_cluster_rec->control_addr,
working_cluster_rec->control_port,
working_cluster_rec->control_host);
if (setenvf(NULL, "SLURM_CLUSTER_NAME", "%s",
working_cluster_rec->name) < 0)
error("unable to set SLURM_CLUSTER_NAME in environment");
add_remote_nodes_to_conf_tbls(msg->node_list, msg->node_addr);
}
开发者ID:SchedMD，项目名称:slurm，代码行数:27，代码来源:working_cluster.c
示例11: term_msg_thread
extern void term_msg_thread(void)
{
slurm_mutex_lock(&thread_flag_mutex);
if (thread_running) {
int fd;
slurm_addr_t addr;
thread_shutdown = true;
/* Open and close a connection to the plugin listening port.
* Allows slurm_accept_msg_conn() to return in _msg_thread()
* so that it can check the thread_shutdown flag.
*/
slurm_set_addr(&addr, nonstop_comm_port, "localhost");
fd = slurm_open_stream(&addr, true);
if (fd != -1) {
/* we don't care if the open failed */
slurm_close(fd);
}
debug2("waiting for slurmctld/nonstop thread to exit");
pthread_join(msg_thread_id, NULL);
msg_thread_id = 0;
thread_shutdown = false;
thread_running = false;
debug2("join of slurmctld/nonstop thread was successful");
}
slurm_mutex_unlock(&thread_flag_mutex);
}
开发者ID:artpol84，项目名称:slurm，代码行数:29，代码来源:msg.c
示例12: _setup_srun_tree_info
static int
_setup_srun_tree_info(const mpi_plugin_client_info_t *job)
{
char *p;
uint16_t p_port;
memset(&tree_info, 0, sizeof(tree_info));
tree_info.this_node = "launcher"; /* not used */
tree_info.parent_id = -2; /* not used */
tree_info.parent_node = NULL; /* not used */
tree_info.num_children = job_info.nnodes;
tree_info.depth = 0; /* not used */
tree_info.max_depth = 0; /* not used */
/* pmi_port set in _setup_srun_sockets */
p = getenv(PMI2_SPAWNER_PORT_ENV);
if (p) { /* spawned */
p_port = atoi(p);
tree_info.srun_addr = xmalloc(sizeof(slurm_addr_t));
/* assume there is always a lo interface */
slurm_set_addr(tree_info.srun_addr, p_port, "127.0.0.1");
} else
tree_info.srun_addr = NULL;
snprintf(tree_sock_addr, 128, PMI2_SOCK_ADDR_FMT,
job->jobid, job->stepid);
/* init kvs seq to 0. TODO: reduce array size */
tree_info.children_kvs_seq = xmalloc(sizeof(uint32_t) *
job_info.nnodes);
return SLURM_SUCCESS;
}
开发者ID:Cray，项目名称:slurm，代码行数:33，代码来源:setup.c
示例13: slurm_msg_t_init
static void *_msg_thread(void *x)
{
struct msg_arg *msg_arg_ptr = (struct msg_arg *) x;
int rc, success = 0, timeout;
slurm_msg_t msg_send;
slurm_msg_t_init(&msg_send);
debug2("KVS_Barrier msg to %s:%u",
msg_arg_ptr->bar_ptr->hostname,
msg_arg_ptr->bar_ptr->port);
msg_send.msg_type = PMI_KVS_GET_RESP;
msg_send.data = (void *) msg_arg_ptr->kvs_ptr;
slurm_set_addr(&msg_send.address,
msg_arg_ptr->bar_ptr->port,
msg_arg_ptr->bar_ptr->hostname);
timeout = slurm_get_msg_timeout() * 10000;
if (slurm_send_recv_rc_msg_only_one(&msg_send, &rc, timeout) < 0) {
error("slurm_send_recv_rc_msg_only_one: %m");
} else if (rc != SLURM_SUCCESS) {
error("KVS_Barrier confirm from %s, rc=%d",
msg_arg_ptr->bar_ptr->hostname, rc);
} else {
/* successfully transmitted KVS keypairs */
success = 1;
}
slurm_mutex_lock(&agent_mutex);
agent_cnt--;
pthread_cond_signal(&agent_cond);
slurm_mutex_unlock(&agent_mutex);
xfree(x);
return NULL;
}
开发者ID:VURM，项目名称:slurm，代码行数:35，代码来源:pmi_server.c
示例14: term_msg_thread
/*****************************************************************************\
* terminate message hander thread
\*****************************************************************************/
extern void term_msg_thread(void)
{
pthread_mutex_lock(&thread_flag_mutex);
if (thread_running) {
int fd;
slurm_addr_t addr;
thread_shutdown = true;
/* Open and close a connection to the listening port.
* Allows slurm_accept_msg_conn() to return in
* _msg_thread() so that it can check the thread_shutdown
* flag.
*/
slurm_set_addr(&addr, sched_port, "localhost");
fd = slurm_open_stream(&addr);
if (fd != -1) {
/* we don't care if the open failed */
slurm_close_stream(fd);
}
debug2("waiting for dynalloc thread to exit");
pthread_join(msg_thread_id, NULL);
msg_thread_id = 0;
thread_shutdown = false;
thread_running = false;
debug2("join of dynalloc thread successful");
}
pthread_mutex_unlock(&thread_flag_mutex);
}
开发者ID:jsollom，项目名称:slurm，代码行数:33，代码来源:msg.c
示例15: srun_timeout
/*
* srun_timeout - notify srun of a job's imminent timeout
* IN job_ptr - pointer to the slurmctld job record
*/
extern void srun_timeout (struct job_record *job_ptr)
{
slurm_addr_t * addr;
srun_timeout_msg_t *msg_arg;
ListIterator step_iterator;
struct step_record *step_ptr;
xassert(job_ptr);
if (!IS_JOB_RUNNING(job_ptr))
return;
if (job_ptr->other_port && job_ptr->alloc_node && job_ptr->resp_host) {
addr = xmalloc(sizeof(struct sockaddr_in));
slurm_set_addr(addr, job_ptr->other_port, job_ptr->resp_host);
msg_arg = xmalloc(sizeof(srun_timeout_msg_t));
msg_arg->job_id = job_ptr->job_id;
msg_arg->step_id = NO_VAL;
msg_arg->timeout = job_ptr->end_time;
_srun_agent_launch(addr, job_ptr->alloc_node, SRUN_TIMEOUT,
msg_arg);
}
step_iterator = list_iterator_create(job_ptr->step_list);
while ((step_ptr = (struct step_record *) list_next(step_iterator))) {
if ( (step_ptr->port == 0) ||
(step_ptr->host == NULL) ||
(step_ptr->batch_step) ||
(step_ptr->host[0] == '\0') )
continue;
addr = xmalloc(sizeof(struct sockaddr_in));
slurm_set_addr(addr, step_ptr->port, step_ptr->host);
msg_arg = xmalloc(sizeof(srun_timeout_msg_t));
msg_arg->job_id = job_ptr->job_id;
msg_arg->step_id = step_ptr->step_id;
msg_arg->timeout = job_ptr->end_time;
_srun_agent_launch(addr, step_ptr->host, SRUN_TIMEOUT,
msg_arg);
}
list_iterator_destroy(step_iterator);
}
开发者ID:Xarthisius，项目名称:slurm，代码行数:45，代码来源:srun_comm.c
示例16: _open_fd
/* Open event_fd as needed
* RET 0 on success, -1 on failure */
static int _open_fd(time_t now)
{
if (event_fd != -1)
return 0;
/* Identify address for socket connection.
* Done only on first call, then cached. */
if (event_addr_set == 0) {
slurm_set_addr(&moab_event_addr, e_port, e_host);
event_addr_set = 1;
if (e_host_bu[0] != '\0') {
slurm_set_addr(&moab_event_addr_bu, e_port,
e_host_bu);
event_addr_set = 2;
}
}
/* Open the event port on moab as needed */
if (event_fd == -1) {
event_fd = slurm_open_msg_conn(&moab_event_addr);
if (event_fd == -1) {
error("Unable to open primary wiki "
"event port %s:%u: %m",
e_host, e_port);
}
}
if ((event_fd == -1) && (event_addr_set == 2)) {
event_fd = slurm_open_msg_conn(&moab_event_addr_bu);
if (event_fd == -1) {
error("Unable to open backup wiki "
"event port %s:%u: %m",
e_host_bu, e_port);
}
}
if (event_fd == -1)
return -1;
/* We can't have the controller block on the following write() */
fd_set_nonblocking(event_fd);
return 0;
}
开发者ID:A1ve5，项目名称:slurm，代码行数:43，代码来源:event.c
示例17: _setup_exec_srun
static void
_setup_exec_srun(spawn_req_t *req)
{
char **env, env_key[32];
int i, rc;
spawn_resp_t *resp;
debug3("mpi/pmi2: in _setup_exec_srun");
/* setup environments */
env = env_array_copy((const char **)job_info.job_env);
/* TODO: unset some env-vars */
env_array_overwrite_fmt(&env, "SLURM_JOB_ID", "%u", job_info.jobid);
env_array_overwrite_fmt(&env, PMI2_SPAWNER_JOBID_ENV, "%s",
job_info.pmi_jobid);
env_array_overwrite_fmt(&env, PMI2_PMI_JOBID_ENV, "%s-%u",
job_info.pmi_jobid, req->seq);
env_array_overwrite_fmt(&env, PMI2_SPAWN_SEQ_ENV, "%u", req->seq);
env_array_overwrite_fmt(&env, PMI2_SPAWNER_PORT_ENV, "%hu",
tree_info.pmi_port);
/* preput kvs */
env_array_overwrite_fmt(&env, PMI2_PREPUT_CNT_ENV, "%d",
req->preput_cnt);
for (i = 0; i < req->preput_cnt; i ++) {
snprintf(env_key, 32, PMI2_PPKEY_ENV"%d", i);
env_array_overwrite_fmt(&env, env_key, "%s", req->pp_keys[i]);
snprintf(env_key, 32, PMI2_PPVAL_ENV"%d", i);
env_array_overwrite_fmt(&env, env_key, "%s", req->pp_vals[i]);
}
if (req->subcmd_cnt == 1) {
/* no return if success */
rc = _exec_srun_single(req, env);
} else {
/* no return if success */
rc = _exec_srun_multiple(req, env);
}
resp = spawn_resp_new();
resp->seq = req->seq;
xstrfmtcat(resp->jobid, "%s-%u", job_info.pmi_jobid, req->seq);
resp->error_cnt = 0;
resp->rc = rc;
/* fake a srun address */
tree_info.srun_addr = xmalloc(sizeof(slurm_addr_t));
slurm_set_addr(tree_info.srun_addr, tree_info.pmi_port,
"127.0.0.1");
spawn_resp_send_to_srun(resp);
spawn_resp_free(resp);
exit(errno);
}
开发者ID:corburn，项目名称:slurm，代码行数:53，代码来源:spawn.c
示例18: srun_user_message
/*
* srun_user_message - Send arbitrary message to an srun job (no job steps)
*/
extern int srun_user_message(struct job_record *job_ptr, char *msg)
{
slurm_addr_t * addr;
srun_user_msg_t *msg_arg;
xassert(job_ptr);
if (!IS_JOB_PENDING(job_ptr) && !IS_JOB_RUNNING(job_ptr))
return ESLURM_ALREADY_DONE;
if (job_ptr->other_port &&
job_ptr->resp_host && job_ptr->resp_host[0]) {
addr = xmalloc(sizeof(struct sockaddr_in));
slurm_set_addr(addr, job_ptr->other_port, job_ptr->resp_host);
msg_arg = xmalloc(sizeof(srun_user_msg_t));
msg_arg->job_id = job_ptr->job_id;
msg_arg->msg = xstrdup(msg);
_srun_agent_launch(addr, job_ptr->resp_host, SRUN_USER_MSG,
msg_arg);
return SLURM_SUCCESS;
} else if (job_ptr->batch_flag && IS_JOB_RUNNING(job_ptr)) {
#ifndef HAVE_FRONT_END
struct node_record *node_ptr;
#endif
job_notify_msg_t *notify_msg_ptr;
agent_arg_t *agent_arg_ptr;
#ifdef HAVE_FRONT_END
if (job_ptr->batch_host == NULL)
return ESLURM_DISABLED; /* no allocated nodes */
agent_arg_ptr = (agent_arg_t *) xmalloc(sizeof(agent_arg_t));
agent_arg_ptr->hostlist = hostlist_create(job_ptr->batch_host);
#else
node_ptr = find_first_node_record(job_ptr->node_bitmap);
if (node_ptr == NULL)
return ESLURM_DISABLED; /* no allocated nodes */
agent_arg_ptr = (agent_arg_t *) xmalloc(sizeof(agent_arg_t));
agent_arg_ptr->hostlist = hostlist_create(node_ptr->name);
#endif
if (agent_arg_ptr->hostlist == NULL)
fatal("hostlist_create: malloc failure");
notify_msg_ptr = (job_notify_msg_t *)
xmalloc(sizeof(job_notify_msg_t));
notify_msg_ptr->job_id = job_ptr->job_id;
notify_msg_ptr->message = xstrdup(msg);
agent_arg_ptr->node_count = 1;
agent_arg_ptr->retry = 0;
agent_arg_ptr->msg_type = REQUEST_JOB_NOTIFY;
agent_arg_ptr->msg_args = (void *) notify_msg_ptr;
/* Launch the RPC via agent */
agent_queue_request(agent_arg_ptr);
return SLURM_SUCCESS;
}
return ESLURM_DISABLED;
}
开发者ID:Xarthisius，项目名称:slurm，代码行数:56，代码来源:srun_comm.c
示例19: _get_addr
static int _get_addr(void)
{
char *env_host, *env_port;
if (srun_port)
return SLURM_SUCCESS;
env_host = getenv("SLURM_SRUN_COMM_HOST");
env_port = getenv("SLURM_SRUN_COMM_PORT");
if (!env_host || !env_port)
return SLURM_ERROR;
srun_port = (uint16_t) atol(env_port);
slurm_set_addr(&srun_addr, srun_port, env_host);
return SLURM_SUCCESS;
}
开发者ID:mart1nl，项目名称:slurm，代码行数:16，代码来源:slurm_pmi.c
示例20: srun_step_complete
/*
* srun_step_complete - notify srun of a job step's termination
* IN step_ptr - pointer to the slurmctld job step record
*/
extern void srun_step_complete (struct step_record *step_ptr)
{
slurm_addr_t * addr;
srun_job_complete_msg_t *msg_arg;
xassert(step_ptr);
if (step_ptr->port && step_ptr->host && step_ptr->host[0]) {
addr = xmalloc(sizeof(struct sockaddr_in));
slurm_set_addr(addr, step_ptr->port, step_ptr->host);
msg_arg = xmalloc(sizeof(srun_job_complete_msg_t));
msg_arg->job_id = step_ptr->job_ptr->job_id;
msg_arg->step_id = step_ptr->step_id;
_srun_agent_launch(addr, step_ptr->host, SRUN_JOB_COMPLETE,
msg_arg);
}
}
开发者ID:Xarthisius，项目名称:slurm，代码行数:20，代码来源:srun_comm.c
注：本文中的slurm_set_addr函数示例由纯净天空整理自Github/MSDocs等源码及文档管理平台，相关代码片段筛选自各路编程大神贡献的开源项目，源码版权归原作者所有，传播和使用请参考对应项目的License；未经允许，请勿转载。 |
客服电话
APP下载
官方微信
请发表评论