Line data Source code
1 : /* Copyright (C) 2013 The PARI group.
2 :
3 : This file is part of the PARI/GP package.
4 :
5 : PARI/GP is free software; you can redistribute it and/or modify it under the
6 : terms of the GNU General Public License as published by the Free Software
7 : Foundation; either version 2 of the License, or (at your option) any later
8 : version. It is distributed in the hope that it will be useful, but WITHOUT
9 : ANY WARRANTY WHATSOEVER.
10 :
11 : Check the License for details. You should have received a copy of it, along
12 : with the package; see the file 'COPYING'. If not, write to the Free Software
13 : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
14 : #include <pthread.h>
15 : #include "pari.h"
16 : #include "paripriv.h"
17 : #include "mt.h"
18 : #if defined(_WIN32)
19 : # include "../systems/mingw/mingw.h"
20 : #endif
21 :
22 : #define DEBUGLEVEL DEBUGLEVEL_mt
23 :
24 : struct mt_queue
25 : {
26 : long no;
27 : pari_sp avma;
28 : struct pari_mainstack *mainstack;
29 : GEN input, output;
30 : GEN worker;
31 : long workid;
32 : pthread_cond_t cond;
33 : pthread_mutex_t mut;
34 : pthread_cond_t *pcond;
35 : pthread_mutex_t *pmut;
36 : };
37 :
38 : struct mt_pstate
39 : {
40 : pthread_t *th;
41 : struct pari_thread *pth;
42 : struct mt_queue *mq;
43 : long n, nbint, last;
44 : long pending;
45 : pthread_cond_t pcond;
46 : pthread_mutex_t pmut;
47 : };
48 :
49 : static THREAD long mt_thread_no = -1;
50 : static struct mt_pstate *pari_mt;
51 :
52 : #define LOCK(x) pthread_mutex_lock(x); do
53 : #define UNLOCK(x) while(0); pthread_mutex_unlock(x)
54 :
55 : void
56 202552710 : mt_sigint_block(void)
57 : {
58 202552710 : if (mt_thread_no>=0)
59 28141206 : pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,NULL);
60 203978343 : }
61 :
62 : void
63 202879627 : mt_sigint_unblock(void)
64 : {
65 202879627 : if (mt_thread_no>=0)
66 28451822 : pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
67 203966416 : }
68 :
69 : void
70 1817 : mt_err_recover(long er)
71 : {
72 1817 : if (mt_thread_no>=0)
73 : {
74 9 : struct mt_pstate *mt = pari_mt;
75 9 : struct mt_queue *mq = mt->mq+mt_thread_no;
76 9 : GEN err = pari_err_last();
77 9 : err = err_get_num(err)==e_STACK ? err_e_STACK: bin_copy(copy_bin(err));
78 9 : LOCK(mq->pmut)
79 : {
80 9 : mq->output = err;
81 9 : pthread_cond_signal(mq->pcond);
82 9 : } UNLOCK(mq->pmut);
83 8 : pthread_exit((void*)1);
84 : }
85 1808 : else mtsingle_err_recover(er);
86 1808 : }
87 :
88 : void
89 0 : mt_break_recover(void)
90 : {
91 0 : if (mt_thread_no<0) mtsingle_err_recover(0);
92 0 : }
93 :
94 : void
95 0 : mt_sigint(void)
96 : {
97 0 : if (pari_mt) pthread_cond_broadcast(&pari_mt->pcond);
98 0 : }
99 :
100 : int
101 216896 : mt_is_parallel(void)
102 : {
103 216896 : return !!pari_mt;
104 : }
105 :
106 : int
107 30903887 : mt_is_thread(void)
108 : {
109 30903887 : return mt_thread_no>=0 ? 1: mtsingle_is_thread();
110 : }
111 :
112 : long
113 383624 : mt_nbthreads(void)
114 : {
115 383624 : return pari_mt ? 1: pari_mt_nbthreads;
116 : }
117 :
118 : void
119 322585 : mt_thread_init(void) { mt_thread_no = 0; }
120 :
121 : void
122 13 : mt_export_add(const char *str, GEN val)
123 : {
124 13 : if (pari_mt)
125 0 : pari_err(e_MISC,"export() not allowed during parallel sections");
126 13 : export_add(str, val);
127 13 : }
128 :
129 : void
130 8 : mt_export_del(const char *str)
131 : {
132 8 : if (pari_mt)
133 0 : pari_err(e_MISC,"unexport() not allowed during parallel sections");
134 8 : export_del(str);
135 8 : }
136 :
137 1 : void mt_broadcast(GEN code) {(void) code;}
138 :
139 262 : void pari_mt_init(void)
140 : {
141 262 : pari_mt = NULL;
142 : #ifdef _SC_NPROCESSORS_CONF
143 262 : if (!pari_mt_nbthreads) pari_mt_nbthreads = sysconf(_SC_NPROCESSORS_CONF);
144 : #elif defined(_WIN32)
145 : if (!pari_mt_nbthreads) pari_mt_nbthreads = win32_nbthreads();
146 : #else
147 : pari_mt_nbthreads = 1;
148 : #endif
149 262 : }
150 :
151 262 : void pari_mt_close(void) { }
152 :
153 : static void
154 323471 : mt_queue_cleanup(void *arg)
155 : {
156 : (void) arg;
157 323471 : pari_thread_close();
158 322010 : }
159 :
160 : static void
161 323054 : mt_queue_unlock(void *arg)
162 323054 : { pthread_mutex_unlock((pthread_mutex_t*) arg); }
163 :
164 : static void*
165 324586 : mt_queue_run(void *arg)
166 : {
167 324586 : GEN args = pari_thread_start((struct pari_thread*) arg);
168 322487 : pari_sp av = avma;
169 322487 : struct mt_queue *mq = (struct mt_queue *) args;
170 322487 : mt_thread_no = mq->no;
171 322487 : pthread_cleanup_push(mt_queue_cleanup,NULL);
172 322857 : LOCK(mq->pmut)
173 : {
174 324589 : mq->mainstack = pari_mainstack;
175 324589 : mq->avma = av;
176 324589 : pthread_cond_signal(mq->pcond);
177 324589 : } UNLOCK(mq->pmut);
178 : for(;;)
179 434772 : {
180 : GEN work, done;
181 759317 : LOCK(&mq->mut)
182 : {
183 759297 : pthread_cleanup_push(mt_queue_unlock, &mq->mut);
184 1170511 : while(!mq->input)
185 735735 : pthread_cond_wait(&mq->cond, &mq->mut);
186 434776 : pthread_cleanup_pop(0);
187 434739 : } UNLOCK(&mq->mut);
188 434741 : pari_mainstack = mq->mainstack;
189 434741 : set_avma(mq->avma);
190 434693 : work = mq->input;
191 434693 : pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL);
192 434814 : done = closure_callgenvec(mq->worker,work);
193 433746 : pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,NULL);
194 434668 : LOCK(mq->pmut)
195 : {
196 434790 : mq->mainstack = pari_mainstack;
197 434790 : mq->avma = av;
198 434790 : mq->input = NULL;
199 434790 : mq->output = done;
200 434790 : pthread_cond_signal(mq->pcond);
201 434790 : } UNLOCK(mq->pmut);
202 : }
203 : pthread_cleanup_pop(1);
204 : #ifdef __GNUC__
205 : return NULL; /* LCOV_EXCL_LINE */
206 : #endif
207 : }
208 :
209 : static long
210 610634 : mt_queue_check(struct mt_pstate *mt)
211 : {
212 : long i;
213 4597762 : for(i=0; i<mt->n; i++)
214 : {
215 4421921 : struct mt_queue *mq = mt->mq+i;
216 4421921 : if (mq->output) return i;
217 : }
218 175841 : return -1;
219 : }
220 :
221 : static GEN
222 700466 : mtpthread_queue_get(struct mt_state *junk, long *workid, long *pending)
223 : {
224 700466 : struct mt_pstate *mt = pari_mt;
225 : struct mt_queue *mq;
226 700466 : GEN done = NULL;
227 : long last;
228 : (void) junk;
229 700466 : if (mt->nbint<mt->n)
230 : {
231 265671 : mt->last = mt->nbint;
232 265671 : *pending = mt->pending;
233 265671 : return NULL;
234 : }
235 434795 : BLOCK_SIGINT_START
236 434795 : LOCK(&mt->pmut)
237 : {
238 610634 : while ((last = mt_queue_check(mt)) < 0)
239 : {
240 175841 : pthread_cond_wait(&mt->pcond, &mt->pmut);
241 175841 : if (PARI_SIGINT_pending)
242 : {
243 2 : int sig = PARI_SIGINT_pending;
244 2 : PARI_SIGINT_pending = 0;
245 2 : pthread_mutex_unlock(&mt->pmut);
246 2 : PARI_SIGINT_block = 0;
247 2 : raise(sig);
248 0 : PARI_SIGINT_block = 1;
249 0 : pthread_mutex_lock(&mt->pmut);
250 : }
251 : }
252 434793 : } UNLOCK(&mt->pmut);
253 434793 : BLOCK_SIGINT_END
254 434793 : mq = mt->mq+last;
255 434793 : done = gcopy(mq->output);
256 434793 : mq->output = NULL;
257 434793 : if (workid) *workid = mq->workid;
258 434793 : if (typ(done) == t_ERROR)
259 : {
260 5 : if (err_get_num(done)==e_STACK)
261 0 : pari_err(e_STACKTHREAD);
262 : else
263 5 : pari_err(0,done);
264 : }
265 434788 : mt->last = last;
266 434788 : mt->pending--;
267 434788 : *pending = mt->pending;
268 434788 : return done;
269 : }
270 :
271 : static void
272 700466 : mtpthread_queue_submit(struct mt_state *junk, long workid, GEN work)
273 : {
274 700466 : struct mt_pstate *mt = pari_mt;
275 700466 : struct mt_queue *mq = mt->mq+mt->last;
276 : (void) junk;
277 700466 : if (!work) { mt->nbint=mt->n; return; }
278 434849 : BLOCK_SIGINT_START
279 434849 : if (mt->nbint<mt->n)
280 : {
281 324152 : mt->nbint++;
282 324152 : LOCK(mq->pmut)
283 : {
284 398196 : while(!mq->avma)
285 74044 : pthread_cond_wait(mq->pcond, mq->pmut);
286 324152 : } UNLOCK(mq->pmut);
287 : }
288 434849 : LOCK(&mq->mut)
289 : {
290 434849 : mq->output = NULL;
291 434849 : mq->workid = workid;
292 434849 : BLOCK_SIGINT_START
293 : {
294 434849 : pari_sp av = avma;
295 434849 : struct pari_mainstack *st = pari_mainstack;
296 434849 : pari_mainstack = mq->mainstack;
297 434849 : set_avma(mq->avma);
298 434849 : mq->input = gcopy(work);
299 434849 : mq->avma = avma;
300 434849 : mq->mainstack = pari_mainstack;
301 434849 : pari_mainstack = st;
302 434849 : set_avma(av);
303 : }
304 434849 : BLOCK_SIGINT_END
305 434849 : pthread_cond_signal(&mq->cond);
306 434849 : } UNLOCK(&mq->mut);
307 434849 : mt->pending++;
308 434849 : BLOCK_SIGINT_END
309 : }
310 :
311 : void
312 58826 : mt_queue_reset(void)
313 : {
314 58826 : struct mt_pstate *mt = pari_mt;
315 : long i;
316 58826 : BLOCK_SIGINT_START
317 383415 : for (i=0; i<mt->n; i++)
318 324589 : pthread_cancel(mt->th[i]);
319 383415 : for (i=0; i<mt->n; i++)
320 324589 : pthread_join(mt->th[i],NULL);
321 58826 : pari_mt = NULL;
322 58826 : BLOCK_SIGINT_END
323 58826 : if (DEBUGLEVEL) pari_warn(warner,"stopping %ld threads", mt->n);
324 383415 : for (i=0;i<mt->n;i++)
325 : {
326 324589 : struct mt_queue *mq = mt->mq+i;
327 324589 : pthread_cond_destroy(&mq->cond);
328 324589 : pthread_mutex_destroy(&mq->mut);
329 324589 : pari_thread_free(&mt->pth[i]);
330 : }
331 58826 : pari_free(mt->mq);
332 58826 : pari_free(mt->pth);
333 58826 : pari_free(mt->th);
334 58826 : pari_free(mt);
335 58826 : }
336 :
337 : static long
338 58826 : closure_has_clone(GEN fun)
339 : {
340 58826 : if (isclone(fun)) return 1;
341 58820 : if (lg(fun) >= 8)
342 : {
343 58261 : GEN f = closure_get_frame(fun);
344 58261 : long i, l = lg(f);
345 217745 : for (i = 1; i < l; i++)
346 160997 : if (isclone(gel(f,i))) return 1;
347 : }
348 57307 : return 0;
349 : }
350 :
351 : void
352 131247 : mt_queue_start_lim(struct pari_mt *pt, GEN worker, long lim)
353 : {
354 131247 : if (lim==0) lim = pari_mt_nbthreads;
355 131228 : else lim = minss(pari_mt_nbthreads, lim);
356 131247 : if (mt_thread_no >= 0)
357 42399 : mtsequential_queue_start(pt, worker);
358 88848 : else if (pari_mt || lim <= 1)
359 30022 : mtsingle_queue_start(pt, worker);
360 : else
361 : {
362 : struct mt_pstate *mt =
363 58826 : (struct mt_pstate*) pari_malloc(sizeof(struct mt_pstate));
364 58826 : long mtparisize = GP_DATA->threadsize? GP_DATA->threadsize: pari_mainstack->rsize;
365 58826 : long mtparisizemax = GP_DATA->threadsizemax;
366 : long i;
367 58826 : if (closure_has_clone(worker))
368 1519 : worker = gcopy(worker); /* to avoid clone_lock race */
369 58826 : mt->mq = (struct mt_queue *) pari_malloc(sizeof(*mt->mq)*lim);
370 58826 : mt->th = (pthread_t *) pari_malloc(sizeof(*mt->th)*lim);
371 58826 : mt->pth = (struct pari_thread *) pari_malloc(sizeof(*mt->pth)*lim);
372 58826 : mt->pending = 0;
373 58826 : mt->n = lim;
374 58826 : mt->nbint = 0;
375 58826 : mt->last = 0;
376 58826 : pthread_cond_init(&mt->pcond,NULL);
377 58826 : pthread_mutex_init(&mt->pmut,NULL);
378 383415 : for (i=0;i<lim;i++)
379 : {
380 324589 : struct mt_queue *mq = mt->mq+i;
381 324589 : mq->no = i;
382 324589 : mq->avma = 0;
383 324589 : mq->mainstack = NULL;
384 324589 : mq->worker = worker;
385 324589 : mq->input = NULL;
386 324589 : mq->output = NULL;
387 324589 : mq->pcond = &mt->pcond;
388 324589 : mq->pmut = &mt->pmut;
389 324589 : pthread_cond_init(&mq->cond,NULL);
390 324589 : pthread_mutex_init(&mq->mut,NULL);
391 324589 : if (mtparisizemax)
392 0 : pari_thread_valloc(&mt->pth[i],mtparisize,mtparisizemax,(GEN)mq);
393 : else
394 324589 : pari_thread_alloc(&mt->pth[i],mtparisize,(GEN)mq);
395 : }
396 58826 : if (DEBUGLEVEL) pari_warn(warner,"starting %ld threads", lim);
397 58826 : BLOCK_SIGINT_START
398 383415 : for (i=0;i<lim;i++)
399 324589 : pthread_create(&mt->th[i],NULL, &mt_queue_run, (void*)&mt->pth[i]);
400 58826 : pari_mt = mt;
401 58826 : BLOCK_SIGINT_END
402 58826 : pt->get=&mtpthread_queue_get;
403 58826 : pt->submit=&mtpthread_queue_submit;
404 58826 : pt->end=&mt_queue_reset;
405 : }
406 131246 : }
|
