1 #define __PTHREAD_EXTRA_INTERNAL
4 #include <pthread_extra.h>
9 #include <sys/resource.h>
10 //#include <sys/siginfo.h>
14 //#include <sys/time.h>
16 //Mutex that ensures proper serialization of (un)pause calls
17 //pthread_mutex_t pthread_pause_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
19 //Semaphore that ensures proper serialization of (un)pause signals
20 sem_t pthread_pause_sem
;
21 //Once control to init the semaphore (and possibly other stuff)
22 pthread_once_t pthread_pause_once_ctrl
= PTHREAD_ONCE_INIT
;
23 void pthread_pause_once(void) {
24 sem_init(&pthread_pause_sem
, 0, 1);
26 void pthread_pause_init() { pthread_once(&pthread_pause_once_ctrl
, &pthread_pause_once
); }
28 ///When this variable is nonzero, only referenced thread is allowed to run
29 ///Access has to be protected by pthread_user_data_lock() and pthread_pause_sem;
30 pthread_t pthread_pause_holder
= PTHREAD_XNULL
;
32 void pthread_pause_handler(const int signal
, siginfo_t
*info
, void *ptr
) {
33 (void)signal
; (void)info
; (void)ptr
;
34 int run
= info
->si_value
.sival_int
;
37 //Post semaphore to confirm that signal is handled
38 sem_post(&pthread_pause_sem
);
40 //Keep waiting for signals until we are supposed to be running
44 sigdelset(&sigset
, PTHREAD_XSIG_STOP
);
49 void pthread_pause_enable() {
50 pthread_pause_init(); //Make sure semaphore is init'd
52 //Add thread to internal registry
53 pthread_user_data_internal(pthread_self());
55 //Nesting signals too deep is not good for stack
56 //You can get runtime stats using following command:
57 //grep -i sig /proc/$(pgrep binary)/status
58 //struct rlimit sigq = {.rlim_cur = 32, .rlim_max=32};
59 //setrlimit(RLIMIT_SIGPENDING, &sigq);
64 sigaddset(&sigset
, PTHREAD_XSIG_STOP
);
66 //Setup signal handler
67 //signal(PTHREAD_XSIG_STOP, pthread_pause_handler);
68 const struct sigaction pause_sa
= {
69 .sa_sigaction
= pthread_pause_handler
,
71 .sa_flags
= SA_SIGINFO
| SA_RESTART
,
74 sigaction(PTHREAD_XSIG_STOP
, &pause_sa
, NULL
);
77 pthread_sigmask(SIG_UNBLOCK
, &sigset
, NULL
);
80 void pthread_pause_disable() {
81 pthread_pause_init(); //Make sure semaphore is init'd
83 //Add thread to internal registry
84 pthread_user_data_internal(pthread_self());
89 sigaddset(&sigset
, PTHREAD_XSIG_STOP
);
91 //Make sure all signals are dispatched before we block them
92 sem_wait(&pthread_pause_sem
);
93 pthread_sigmask(SIG_BLOCK
, &sigset
, NULL
);
94 sem_post(&pthread_pause_sem
);
98 int pthread_pause_reschedule(pthread_t thread) {
99 //Send signal to initiate pause handler
100 //printf("SND: %p\n", (void *)pthread_user_data_internal(thread));
101 //while(pthread_kill(thread, PTHREAD_XSIG_STOP) == EAGAIN) usleep(1000);
102 while(pthread_sigqueue(thread, PTHREAD_XSIG_STOP,
103 (const union sigval){.sival_ptr=pthread_user_data_internal(thread)}
104 ) == EAGAIN) usleep(1000);
109 int pthread_pause_reschedule(pthread_t thread
) {
110 //Decide if the thread should run and signal it
112 pthread_user_data_lock();
114 //Wait for semaphore which means signal queue is empty
115 pthread_pause_init(); //Make sure semaphore is init'd
116 sem_wait(&pthread_pause_sem
);
118 //Only call this if you already acquired pthread_pause_sem semaphore!!!!
119 //Otherwise call pthread_pause_reschedule()
121 //Check if thread has running flag
122 int run
= (pthread_user_data_internal(thread
)->running
);
123 //Check if privileged (single thread) mode is active
124 if(!pthread_equal(pthread_pause_holder
, PTHREAD_XNULL
) && !pthread_equal(pthread_pause_holder
, thread
)) {
128 //Send signal to initiate pause handler (keep trying while SigQueue is full)
129 //while(pthread_kill(thread, PTHREAD_XSIG_STOP) == EAGAIN) usleep(1000);
130 //printf("Sched %lu = %d (self: %lu, lck: %lu)\n", thread, run, pthread_self(), pthread_pause_holder);
131 while(pthread_sigqueue(thread
, PTHREAD_XSIG_STOP
,
132 (const union sigval
){.sival_int
=run
}
133 ) == EAGAIN
) usleep(1000);
135 //Wait for signal to be delivered
136 sem_wait(&pthread_pause_sem
);
137 sem_post(&pthread_pause_sem
);
138 pthread_user_data_unlock();
143 int pthread_extra_yield() {
144 //Yield to both schedulers
145 pthread_pause_reschedule(pthread_self());
146 return pthread_yield();
149 int pthread_pause(pthread_t thread
) {
150 //Set thread as paused and notify it via signal (wait when queue full)
151 pthread_user_data_lock();
152 pthread_user_data_internal(thread
)->running
= 0;
153 pthread_pause_reschedule(thread
);
154 pthread_user_data_unlock();
158 int pthread_unpause(pthread_t thread
) {
159 //Set thread as running and notify it via signal (wait when queue full)
160 pthread_user_data_lock();
161 pthread_user_data_internal(thread
)->running
= 1;
162 pthread_pause_reschedule(thread
);
163 pthread_user_data_unlock();
167 ///Enter exclusive mode by pausing everyone else
168 int pthread_pause_all() {
169 //printf("Pause ALL\n");
170 pthread_user_data_lock();
171 //printf("Pause ALL+\n");
172 //printf("Pause %p == %p\n", (void *)pthread_pause_holder, (void *)pthread_self());
173 if(!pthread_equal(pthread_pause_holder
,PTHREAD_XNULL
)) assert(pthread_equal(pthread_pause_holder
, pthread_self()));
174 pthread_pause_holder
= pthread_self();
175 pthread_user_data_internal_iterate(&pthread_pause_reschedule
, NULL
);
176 //printf("Pause ALL!\n");
177 pthread_user_data_unlock();
181 ///Leave exclusive mode by unpausing everyone else
182 int pthread_unpause_all() {
183 //printf("UnPause ALL\n");
184 pthread_user_data_lock();
185 //printf("UnPause ALL+\n");
186 if(!pthread_equal(pthread_pause_holder
,PTHREAD_XNULL
)) assert(pthread_equal(pthread_pause_holder
, pthread_self()));
187 pthread_pause_holder
= PTHREAD_XNULL
;
188 pthread_user_data_internal_iterate(&pthread_pause_reschedule
, NULL
);
189 //printf("UnPause ALL!\n");
190 pthread_user_data_unlock();
195 // Wrappers ///////////////////////////////////////////////////////////
198 typedef struct pthread_extra_wrapper_t
{
199 void *(*start_routine
)(void *);
201 } pthread_extra_wrapper_t
;
203 void *pthread_extra_thread_wrapper(void *arg
) {
204 pthread_extra_wrapper_t task
= *((pthread_extra_wrapper_t
*)arg
);
207 //Register new thread to user data structure
208 pthread_user_data_internal(pthread_self()); //Perhaps already done in pthread_extra_yield()??
210 //TODO: user_data should do this automaticaly?
211 pthread_cleanup_push(pthread_user_data_cleanup
, (void *)pthread_self());
213 //Check if we should be running according to pthread_pause sub-scheduler
214 //pthread_pause_reschedule(pthread_self());
215 pthread_extra_yield();
218 return task
.start_routine(task
.arg
);
220 pthread_cleanup_pop(1); //Needed by pthread_cleanup_push() macro
223 int pthread_extra_create(pthread_t
*restrict thread
,
224 const pthread_attr_t
*restrict attr
,
225 void *(*start_routine
)(void *),
226 void *restrict arg
) {
228 pthread_extra_wrapper_t
*task
= malloc(sizeof(pthread_extra_wrapper_t
));
229 assert(task
!= NULL
);
230 task
->start_routine
=start_routine
;
232 return pthread_create(thread
, attr
, pthread_extra_thread_wrapper
, task
);