1 /*** worker-asyneq.c -- worker threads for asyneq feature
3 * Copyright (C) 2006-2008 Sebastian Freundt
5 * Author: Sebastian Freundt <hroptatyr@sxemacs.org>
7 * This file is part of SXEmacs.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the author nor the names of any contributors
21 * may be used to endorse or promote products derived from this
22 * software without specific prior written permission.
24 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
25 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
26 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
31 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
32 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
33 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
34 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 /* Synched up with: Not in FSF. */
42 #include "syssignal.h"
43 #include "worker-asyneq.h"
44 #define INCLUDE_EVENTS_H_PRIVATE_SPHERE
47 event_queue_t delegate_eq = Qnull_pointer;
48 static Lisp_Object Vdelegate_eq;
49 static void eq_worker_th_blksig(void);
51 static struct work_handler_s eat_yerself = {
59 init_workers(int nthreads, sxe_thread_f handler)
64 pthread_attr_init(&attr);
65 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
67 for (i=0; i < nthreads; i++) {
68 eq_worker_t eqw = eq_make_worker();
69 /* value taken from SOUND_MAX_AUDIO_FRAME_SIZE */
70 resize_worker_scratch(eqw, 48000*6*sizeof(uint32_t));
72 &eq_worker_thread(eqw), &attr, handler, eqw);
73 dllist_append(workers, eqw);
76 pthread_attr_destroy(&attr);
81 fini_worker(eq_worker_t eqw)
83 xthread_join(eq_worker_thread(eqw), NULL);
84 SXE_MUTEX_UNLOCK(&eq_worker_mtx(eqw));
89 extern event_queue_t asyneq;
92 eq_worker_eaten_myself(eq_worker_t eqw)
94 Lisp_Object emev = Qnil;
98 emev = make_empty_event();
99 XEVENT(emev)->event_type = eaten_myself_event;
100 XEVENT(emev)->event.eaten_myself.worker = eqw;
101 eq_enqueue(asyneq, emev);
103 asyneq_handle_event(asyneq);
108 eq_worker_work_started(Lisp_Object job)
110 Lisp_Object wsev = Qnil;
114 wsev = make_empty_event();
115 XEVENT(wsev)->event_type = work_started_event;
116 XEVENT(wsev)->event.work_started.job = job;
117 eq_enqueue(asyneq, wsev);
119 asyneq_handle_event(asyneq);
124 eq_worker_work_finished(Lisp_Object job)
126 Lisp_Object wfev = Qnil;
130 wfev = make_empty_event();
131 XEVENT(wfev)->event_type = work_finished_event;
132 XEVENT(wfev)->event.work_finished.job = job;
133 eq_enqueue(asyneq, wfev);
135 asyneq_handle_event(asyneq);
140 eq_delegate_work(event_queue_t eq)
142 int cur = eq_queue_size(eq);
144 eq_queue_trigger(eq);
151 eq_worker_th_blksig(void)
153 EMACS_BLOCK_SIGNAL(SIGINT); /* ANSI */
154 EMACS_BLOCK_SIGNAL(SIGILL); /* ANSI */
155 EMACS_BLOCK_SIGNAL(SIGABRT); /* ANSI */
156 EMACS_BLOCK_SIGNAL(SIGFPE); /* ANSI */
157 EMACS_BLOCK_SIGNAL(SIGSEGV); /* ANSI */
158 EMACS_BLOCK_SIGNAL(SIGTERM); /* ANSI */
161 EMACS_BLOCK_SIGNAL(SIGHUP); /* POSIX */
164 EMACS_BLOCK_SIGNAL(SIGQUIT); /* POSIX */
167 EMACS_BLOCK_SIGNAL(SIGTRAP); /* POSIX */
170 EMACS_BLOCK_SIGNAL(SIGUSR1); /* POSIX */
173 EMACS_BLOCK_SIGNAL(SIGUSR2); /* POSIX */
176 EMACS_BLOCK_SIGNAL(SIGPIPE); /* POSIX */
179 EMACS_BLOCK_SIGNAL(SIGALRM); /* POSIX */
182 EMACS_BLOCK_SIGNAL(SIGCHLD); /* POSIX */
185 EMACS_BLOCK_SIGNAL(SIGCONT); /* POSIX */
188 EMACS_BLOCK_SIGNAL(SIGSTOP); /* POSIX */
191 EMACS_BLOCK_SIGNAL(SIGTSTP); /* POSIX */
194 EMACS_BLOCK_SIGNAL(SIGTTIN); /* POSIX */
197 EMACS_BLOCK_SIGNAL(SIGTTOU); /* POSIX */
201 EMACS_BLOCK_SIGNAL(SIGBUS); /* XPG5 */
204 EMACS_BLOCK_SIGNAL(SIGPOLL); /* XPG5 */
207 EMACS_BLOCK_SIGNAL(SIGPROF); /* XPG5 */
210 EMACS_BLOCK_SIGNAL(SIGSYS); /* XPG5 */
213 EMACS_BLOCK_SIGNAL(SIGURG); /* XPG5 */
216 EMACS_BLOCK_SIGNAL(SIGXCPU); /* XPG5 */
219 EMACS_BLOCK_SIGNAL(SIGXFSZ); /* XPG5 */
221 #if defined SIGVTALRM
222 EMACS_BLOCK_SIGNAL(SIGVTALRM); /* XPG5 */
226 EMACS_BLOCK_SIGNAL(SIGIO); /* BSD 4.2 */
229 EMACS_BLOCK_SIGNAL(SIGWINCH); /* BSD 4.3 */
233 EMACS_BLOCK_SIGNAL(SIGEMT);
236 EMACS_BLOCK_SIGNAL(SIGINFO);
239 EMACS_BLOCK_SIGNAL(SIGHWE);
242 EMACS_BLOCK_SIGNAL(SIGPRE);
245 EMACS_BLOCK_SIGNAL(SIGUME);
248 EMACS_BLOCK_SIGNAL(SIGDLK);
250 #if defined SIGCPULIM
251 EMACS_BLOCK_SIGNAL(SIGCPULIM);
254 EMACS_BLOCK_SIGNAL(SIGIOT);
257 # if !defined HAVE_BDWGC || !defined EF_USE_BDWGC
258 EMACS_BLOCK_SIGNAL(SIGLOST);
259 # endif /* BDWGC case */
261 #if defined SIGSTKFLT
262 EMACS_BLOCK_SIGNAL(SIGSTKFLT);
264 #if defined SIGUNUSED
265 EMACS_BLOCK_SIGNAL(SIGUNUSED);
267 #if defined SIGDANGER
268 EMACS_BLOCK_SIGNAL(SIGDANGER); /* AIX */
271 EMACS_BLOCK_SIGNAL(SIGMSG);
274 EMACS_BLOCK_SIGNAL(SIGSOUND);
276 #if defined SIGRETRACT
277 EMACS_BLOCK_SIGNAL(SIGRETRACT);
280 EMACS_BLOCK_SIGNAL(SIGGRANT);
283 # if !defined HAVE_BDWGC || !defined EF_USE_BDWGC
284 EMACS_BLOCK_SIGNAL(SIGPWR);
285 # endif /* BDWGC case */
290 eq_worker_th(void *eqwptr)
292 Lisp_Object ljob = Qnil;
293 worker_job_t job = NULL;
294 eq_worker_t eqw = eqwptr;
298 eq_worker_th_blksig();
302 eq_queue_synch(delegate_eq);
304 EQUEUE_DEBUG_WORKER("dequeuing thread: 0x%lx\n",
305 (long unsigned int)pthread_self());
307 /* fetch one event now */
310 eq_dequeue_pro(&ljob, delegate_eq);
312 EQUEUE_DEBUG_WORKER("No event on the queue. "
313 "Who dared to wake me up?! >8(\n");
318 job = XWORKER_JOB(ljob);
319 hdl = XWORKER_JOB_HANDLER(ljob);
320 EQUEUE_DEBUG_WORKER("escrowing event 0x%lx in worker 0x%lx.\n",
321 (long unsigned int)job,
322 (long unsigned int)eqw);
324 /* maybe it's a eat-yourself ticket? */
325 if (hdl == &eat_yerself) {
326 /* awww ... we gotta exit :( */
328 "Worker 0x%lx commits suicide...\n",
329 (long unsigned int)eqw);
330 eq_unlock_meself(eqw);
331 eq_worker_eaten_myself(eqw);
337 /* help the job a bit with local resources */
338 EQUEUE_DEBUG_SCRATCH("inherit scratch buffer 0x%lx of size %ld\n",
339 (long unsigned int)eq_worker_scratch(eqw),
340 eq_worker_scratch_alloc_size(eqw));
341 worker_job_buffer(job) = eq_worker_scratch(eqw);
342 worker_job_buffer_alloc_size(job) = eq_worker_scratch_alloc_size(eqw);
344 /* generate a started event and update job state */
345 worker_job_state(job) = WORKER_JOB_RUNNING;
346 eq_worker_work_started(ljob);
348 /* ... otherwise handle the event */
349 work_handler(hdl)(job);
351 /* generate a `finished' event,
352 * sentinel code shall be injected in the routine
353 * called by eq_worker_handle_event() */
354 worker_job_state(job) = WORKER_JOB_FINISHED;
355 eq_worker_work_finished(ljob);
357 eq_unlock_meself(eqw);
359 EQUEUE_DEBUG_WORKER("enqueuing thread: 0x%lx\n",
360 (long unsigned int)pthread_self());
366 DEFUN("init-workers", Finit_workers, 1, 1, 0, /*
367 Initialise NUMBER-OF-WORKERS worker threads.
368 If called repeatedly this function does NOT add more workers
369 use `add-workers' instead.
373 CHECK_NATNUM(number_of_workers);
374 if (dllist_get_size(workers) <= 1) {
375 init_workers(XINT(number_of_workers), eq_worker_th);
381 DEFUN("add-workers", Fadd_workers, 1, 1, 0, /*
382 Add NUMBER-OF-WORKERS worker threads.
386 CHECK_NATNUM(number_of_workers);
387 init_workers(XINT(number_of_workers), eq_worker_th);
391 DEFUN("remove-workers", Fremove_workers, 0, 1, 0, /*
392 Stop NUMBER-OF-WORKERS worker threads. By default stop all.
393 Depending on whether there are busy this operation may block the
394 main execution loop until all worker threads are non-busy.
398 Lisp_Object job = Qnil;
399 int i, noev = 0; /* how many eat_yerself events to send? */
402 if (NILP(number_of_workers)) {
403 noev = dllist_get_size(workers)-1;
405 CHECK_NATNUM(number_of_workers);
406 noev = XINT(number_of_workers);
410 for (i = 0; i < noev; i++) {
411 job = wrap_object(make_worker_job(&eat_yerself));
412 eq_enqueue(delegate_eq, job);
414 eq_queue_trigger_all(delegate_eq);
419 DEFUN("trigger-workers", Ftrigger_workers, 0, 0, 0, /*
420 Trigger all worker threads.
424 eq_queue_trigger_all(delegate_eq);
428 DEFUN("running-workers", Frunning_workers, 0, 0, 0, /*
429 Return the number of currently running worker threads,
430 the main thread excluded.
434 return make_int(dllist_get_size(workers)-1);
438 void syms_of_worker_asyneq(void)
440 DEFSUBR(Finit_workers);
441 DEFSUBR(Fadd_workers);
442 DEFSUBR(Fremove_workers);
443 DEFSUBR(Ftrigger_workers);
444 DEFSUBR(Frunning_workers);
447 void reinit_vars_of_worker_asyneq(void)
449 /* the delegate queue in case of multiple threads */
450 delegate_eq = make_event_queue();
451 XSETEVENT_QUEUE(Vdelegate_eq, delegate_eq);
452 staticpro_nodump(&Vdelegate_eq);
455 void vars_of_worker_asyneq(void)
457 Fprovide(intern("asyneq"));
460 /* workers.c ends here */