1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
/*
* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
* University Research and Technology
* Corporation. All rights reserved.
* Copyright (c) 2004-2011 The University of Tennessee and The University
* of Tennessee Research Foundation. All rights
* reserved.
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
* University of Stuttgart. All rights reserved.
* Copyright (c) 2004-2005 The Regents of the University of California.
* All rights reserved.
* Copyright (c) 2008 Institut National de Recherche en Informatique
* et Automatique. All rights reserved.
* Copyright (c) 2011 Los Alamos National Security, LLC.
* All rights reserved.
* Copyright (c) 2014 Intel, Inc. All rights reserved.
* $COPYRIGHT$
*
* Additional copyrights may follow
*
* $HEADER$
*/
/**
* @file
*
* Interface for waitpid / async notification of child death with the
* libevent runtime system.
*/
#ifndef ORTE_WAIT_H
#define ORTE_WAIT_H
#include "orte_config.h"
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#include <time.h>
#if HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#include "opal/dss/dss.h"
#include "opal/util/output.h"
#include "opal/sys/atomic.h"
#include "opal/mca/event/event.h"
#include "orte/types.h"
#include "orte/mca/rml/rml_types.h"
#include "orte/runtime/orte_globals.h"
BEGIN_C_DECLS
/** typedef for callback function used in \c orte_wait_cb */
typedef void (*orte_wait_fn_t)(orte_proc_t *proc, void *data);
/**
* Disable / re-Enable SIGCHLD handler
*
* These functions have to be used after orte_wait_init was called.
*/
ORTE_DECLSPEC void orte_wait_enable(void);
ORTE_DECLSPEC void orte_wait_disable(void);
/**
* Register a callback for process termination
*
* Register a callback for notification when this process causes a SIGCHLD.
* \c waitpid() will have already been called on the process at this
* time.
*/
ORTE_DECLSPEC void orte_wait_cb(orte_proc_t *proc, orte_wait_fn_t callback, void *data);
ORTE_DECLSPEC void orte_wait_cb_cancel(orte_proc_t *proc);
/* In a few places, we need to barrier until something happens
* that changes a flag to indicate we can release - e.g., waiting
* for a specific message to arrive. If no progress thread is running,
* we cycle across opal_progress - however, if a progress thread
* is active, then we need to just nanosleep to avoid cross-thread
* confusion
*/
#define ORTE_WAIT_FOR_COMPLETION(flg) \
do { \
opal_output_verbose(1, orte_progress_thread_debug, \
"%s waiting on progress thread at %s:%d", \
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), \
__FILE__, __LINE__); \
while ((flg)) { \
/* provide a short quiet period so we \
* don't hammer the cpu while waiting \
*/ \
struct timespec tp = {0, 100000}; \
nanosleep(&tp, NULL); \
} \
}while(0);
/**
* In a number of places within the code, we want to setup a timer
* to detect when some procedure failed to complete. For example,
* when we launch the daemons, we frequently have no way to directly
* detect that a daemon failed to launch. Setting a timer allows us
* to automatically fail out of the launch if we don't hear from a
* daemon in some specified time window.
*
* Computing the amount of time to wait takes a few lines of code, but
* this macro encapsulates those lines along with the timer event
* definition just as a convenience. It also centralizes the
* necessary checks to ensure that the microsecond field is always
* less than 1M since some systems care about that, and to ensure
* that the computed wait time doesn't exceed the desired max
* wait
*
* NOTE: the callback function is responsible for releasing the timer
* event back to the event pool!
*/
#define ORTE_DETECT_TIMEOUT(n, deltat, maxwait, cbfunc, cbd) \
do { \
orte_timer_t *tmp; \
int timeout; \
tmp = OBJ_NEW(orte_timer_t); \
tmp->payload = (cbd); \
opal_event_evtimer_set(orte_event_base, \
tmp->ev, (cbfunc), tmp); \
opal_event_set_priority(tmp->ev, ORTE_ERROR_PRI); \
timeout = (deltat) * (n); \
if ((maxwait) > 0 && timeout > (maxwait)) { \
timeout = (maxwait); \
} \
tmp->tv.tv_sec = timeout/1000000; \
tmp->tv.tv_usec = timeout%1000000; \
OPAL_OUTPUT_VERBOSE((1, orte_debug_output, \
"defining timeout: %ld sec %ld usec at %s:%d", \
(long)tmp->tv.tv_sec, (long)tmp->tv.tv_usec, \
__FILE__, __LINE__)); \
opal_event_evtimer_add(tmp->ev, &tmp->tv); \
}while(0); \
/**
* There are places in the code where we just want to periodically
* wakeup to do something, and then go back to sleep again. Setting
* a timer allows us to do this
*
* NOTE: the callback function is responsible for releasing the timer
* event back to the event pool when done! Otherwise, the finalize
* function will take care of it.
*/
#define ORTE_TIMER_EVENT(sec, usec, cbfunc, pri) \
do { \
orte_timer_t *tm; \
tm = OBJ_NEW(orte_timer_t); \
opal_event_evtimer_set(orte_event_base, \
tm->ev, (cbfunc), tm); \
opal_event_set_priority(tm->ev, (pri)); \
tm->tv.tv_sec = (sec) + (usec)/1000000; \
tm->tv.tv_usec = (usec) % 1000000; \
OPAL_OUTPUT_VERBOSE((1, orte_debug_output, \
"defining timer event: %ld sec %ld usec at %s:%d", \
(long)tm->tv.tv_sec, (long)tm->tv.tv_usec, \
__FILE__, __LINE__)); \
opal_event_evtimer_add(tm->ev, &tm->tv); \
}while(0); \
/**
* \internal
*
* Initialize the wait system (allocate mutexes, etc.)
*/
ORTE_DECLSPEC int orte_wait_init(void);
/**
* \internal
*
* Finalize the wait system (deallocate mutexes, etc.)
*/
ORTE_DECLSPEC int orte_wait_finalize(void);
END_C_DECLS
#endif /* #ifndef ORTE_WAIT_H */
|
