| 147 |
|
#include "selcall.h" |
| 148 |
|
|
| 149 |
|
#ifndef RAYQLEN |
| 150 |
< |
#define RAYQLEN 12 /* # rays to send at once */ |
| 150 |
> |
#define RAYQLEN 24 /* # rays to send at once */ |
| 151 |
|
#endif |
| 152 |
|
|
| 153 |
|
#ifndef MAX_RPROCS |
| 164 |
|
int ray_pnidle = 0; /* number of idle children */ |
| 165 |
|
|
| 166 |
|
static struct child_proc { |
| 167 |
< |
int pid; /* child process id */ |
| 167 |
> |
RT_PID pid; /* child process id */ |
| 168 |
|
int fd_send; /* write to child here */ |
| 169 |
|
int fd_recv; /* read from child here */ |
| 170 |
|
int npending; /* # rays in process */ |
| 176 |
|
static int r_recv_first = RAYQLEN; /* position of first unreported ray */ |
| 177 |
|
static int r_recv_next = RAYQLEN; /* next received ray placement */ |
| 178 |
|
|
| 179 |
+ |
static int samplestep = 1; /* sample step size */ |
| 180 |
+ |
|
| 181 |
|
#define sendq_full() (r_send_next >= RAYQLEN) |
| 182 |
|
|
| 183 |
|
static int ray_pflush(void); |
| 212 |
|
for (i = ray_pnprocs; nc && i--; ) { |
| 213 |
|
if (r_proc[i].npending > 0) |
| 214 |
|
continue; /* child looks busy */ |
| 215 |
< |
n = (r_send_next - sfirst)/nc--; |
| 215 |
> |
n = (r_send_next - sfirst) / nc--; |
| 216 |
|
if (!n) |
| 217 |
|
continue; |
| 218 |
|
/* smuggle set size in crtype */ |
| 290 |
|
static struct timeval tpoll; /* zero timeval struct */ |
| 291 |
|
static fd_set readset, errset; |
| 292 |
|
int n, ok; |
| 293 |
< |
register int pn; |
| 293 |
> |
int pn; |
| 294 |
|
|
| 295 |
|
if (r == NULL) |
| 296 |
|
return(0); |
| 368 |
|
} |
| 369 |
|
/* preen returned rays */ |
| 370 |
|
for (n = r_recv_next - r_recv_first; n--; ) { |
| 371 |
< |
register RAY *rp = &r_queue[r_recv_first + n]; |
| 371 |
> |
RAY *rp = &r_queue[r_recv_first + n]; |
| 372 |
|
rp->rno = r_proc[pn].rno[n]; |
| 373 |
|
rp->parent = NULL; |
| 374 |
|
rp->newcset = rp->clipset = NULL; |
| 404 |
|
) |
| 405 |
|
{ |
| 406 |
|
int n; |
| 407 |
< |
register int i; |
| 407 |
> |
int i; |
| 408 |
|
/* flag child process for quit() */ |
| 409 |
|
ray_pnprocs = -1; |
| 410 |
|
/* read each ray request set */ |
| 430 |
|
r_queue[i].clipset = NULL; |
| 431 |
|
r_queue[i].slights = NULL; |
| 432 |
|
r_queue[i].rlvl = 0; |
| 433 |
< |
samplendx++; |
| 433 |
> |
samplendx += samplestep; |
| 434 |
|
rayclear(&r_queue[i]); |
| 435 |
|
rayvalue(&r_queue[i]); |
| 436 |
|
} |
| 464 |
|
strcpy(shm_boundary, "SHM_BOUNDARY"); |
| 465 |
|
} |
| 466 |
|
fflush(NULL); /* clear pending output */ |
| 467 |
+ |
samplestep = ray_pnprocs + nadd; |
| 468 |
|
while (nadd--) { /* fork each new process */ |
| 469 |
|
int p0[2], p1[2]; |
| 470 |
|
if (pipe(p0) < 0 || pipe(p1) < 0) |
| 483 |
|
if (r_proc[ray_pnprocs].pid < 0) |
| 484 |
|
error(SYSTEM, "cannot fork child process"); |
| 485 |
|
close(p1[0]); close(p0[1]); |
| 486 |
< |
if (rand_samp) /* desynchronize random function */ |
| 487 |
< |
srandom((long)r_proc[ray_pnprocs].pid); |
| 486 |
> |
if (rand_samp) /* decorrelate random sequence */ |
| 487 |
> |
srandom(random()); |
| 488 |
> |
else |
| 489 |
> |
samplendx++; |
| 490 |
|
/* |
| 491 |
|
* Close write stream on exec to avoid multiprocessing deadlock. |
| 492 |
|
* No use in read stream without it, so set flag there as well. |
| 508 |
|
) |
| 509 |
|
{ |
| 510 |
|
static int inclose = 0; |
| 511 |
< |
RAY res; |
| 511 |
> |
RAY res; |
| 512 |
> |
int i, status = 0; |
| 513 |
> |
/* check no child / in child */ |
| 514 |
> |
if (ray_pnprocs <= 0) |
| 515 |
> |
return; |
| 516 |
|
/* check recursion */ |
| 517 |
|
if (inclose) |
| 518 |
|
return; |
| 519 |
|
inclose++; |
| 511 |
– |
/* check no child / in child */ |
| 512 |
– |
if (ray_pnprocs <= 0) |
| 513 |
– |
return; |
| 520 |
|
/* check argument */ |
| 521 |
|
if ((nsub <= 0) | (nsub > ray_pnprocs)) |
| 522 |
|
nsub = ray_pnprocs; |
| 523 |
|
/* clear our ray queue */ |
| 524 |
+ |
i = r_send_next; |
| 525 |
+ |
r_send_next = 0; |
| 526 |
|
while (ray_presult(&res,0) > 0) |
| 527 |
< |
; |
| 528 |
< |
r_send_next = 0; /* hard reset in case of error */ |
| 527 |
> |
++i; |
| 528 |
> |
if (i) { |
| 529 |
> |
sprintf(errmsg, "dropped %d rays in ray_pclose()", i); |
| 530 |
> |
error(WARNING, errmsg); |
| 531 |
> |
} |
| 532 |
|
r_recv_first = r_recv_next = RAYQLEN; |
| 533 |
< |
/* clean up children */ |
| 534 |
< |
while (nsub--) { |
| 535 |
< |
int status; |
| 536 |
< |
ray_pnprocs--; |
| 537 |
< |
close(r_proc[ray_pnprocs].fd_send); |
| 538 |
< |
if (waitpid(r_proc[ray_pnprocs].pid, &status, 0) < 0) |
| 533 |
> |
/* close send pipes */ |
| 534 |
> |
for (i = ray_pnprocs-nsub; i < ray_pnprocs; i++) |
| 535 |
> |
close(r_proc[i].fd_send); |
| 536 |
> |
|
| 537 |
> |
if (nsub == 1) { /* awaiting single process? */ |
| 538 |
> |
if (waitpid(r_proc[ray_pnprocs-1].pid, &status, 0) < 0) |
| 539 |
|
status = 127<<8; |
| 540 |
< |
close(r_proc[ray_pnprocs].fd_recv); |
| 541 |
< |
if (status) { |
| 542 |
< |
sprintf(errmsg, |
| 543 |
< |
"rendering process %d exited with code %d", |
| 544 |
< |
r_proc[ray_pnprocs].pid, status>>8); |
| 545 |
< |
error(WARNING, errmsg); |
| 540 |
> |
close(r_proc[ray_pnprocs-1].fd_recv); |
| 541 |
> |
} else /* else unordered wait */ |
| 542 |
> |
for (i = 0; i < nsub; ) { |
| 543 |
> |
int j, mystatus; |
| 544 |
> |
RT_PID pid = wait(&mystatus); |
| 545 |
> |
if (pid < 0) { |
| 546 |
> |
status = 127<<8; |
| 547 |
> |
break; |
| 548 |
> |
} |
| 549 |
> |
for (j = ray_pnprocs-nsub; j < ray_pnprocs; j++) |
| 550 |
> |
if (r_proc[j].pid == pid) { |
| 551 |
> |
if (mystatus) |
| 552 |
> |
status = mystatus; |
| 553 |
> |
close(r_proc[j].fd_recv); |
| 554 |
> |
++i; |
| 555 |
> |
} |
| 556 |
|
} |
| 557 |
< |
ray_pnidle--; |
| 557 |
> |
ray_pnprocs -= nsub; |
| 558 |
> |
ray_pnidle -= nsub; |
| 559 |
> |
if (status) { |
| 560 |
> |
sprintf(errmsg, "rendering process exited with code %d", status>>8); |
| 561 |
> |
error(WARNING, errmsg); |
| 562 |
|
} |
| 563 |
|
inclose--; |
| 564 |
|
} |
