| 71 |
|
* |
| 72 |
|
* If the second argument is 1, the call won't block when |
| 73 |
|
* results aren't ready, but will immediately return 0. |
| 74 |
+ |
* (A special value of -1 returns 0 unless a ray is |
| 75 |
+ |
* ready in the queue and no system calls are needed.) |
| 76 |
|
* If the second argument is 0, the call will block |
| 77 |
|
* until a value is available, returning 0 only if the |
| 78 |
|
* queue is completely empty. A negative return value |
| 99 |
|
* and fonts that are likely to be used in subsequent renderings. |
| 100 |
|
* Whether you need to clean up memory or not, you should |
| 101 |
|
* at least call ray_pclose(0) to await the child processes. |
| 102 |
+ |
* The caller should define a quit() function that calls |
| 103 |
+ |
* ray_pclose(0) if ray_pnprocs > 0. |
| 104 |
|
* |
| 105 |
|
* Warning: You cannot affect any of the rendering processes |
| 106 |
|
* by changing global parameter values onece ray_pinit() has |
| 158 |
|
|
| 159 |
|
extern char *shm_boundary; /* boundary of shared memory */ |
| 160 |
|
|
| 157 |
– |
int ray_pfifo = 0; /* maintain ray call order? */ |
| 161 |
|
int ray_pnprocs = 0; /* number of child processes */ |
| 162 |
|
int ray_pnidle = 0; /* number of idle children */ |
| 163 |
|
|
| 170 |
|
} r_proc[MAX_NPROCS]; /* our child processes */ |
| 171 |
|
|
| 172 |
|
static RAY r_queue[2*RAYQLEN]; /* ray i/o buffer */ |
| 173 |
< |
static int r_send_next; /* next send ray placement */ |
| 174 |
< |
static int r_recv_first; /* position of first unreported ray */ |
| 175 |
< |
static int r_recv_next; /* next receive ray placement */ |
| 173 |
> |
static int r_send_next = 0; /* next send ray placement */ |
| 174 |
> |
static int r_recv_first = RAYQLEN; /* position of first unreported ray */ |
| 175 |
> |
static int r_recv_next = RAYQLEN; /* next received ray placement */ |
| 176 |
|
|
| 177 |
|
#define sendq_full() (r_send_next >= RAYQLEN) |
| 178 |
|
|
| 180 |
|
static void ray_pchild(int fd_in, int fd_out); |
| 181 |
|
|
| 182 |
|
|
| 183 |
< |
extern void |
| 183 |
> |
void |
| 184 |
|
ray_pinit( /* initialize ray-tracing processes */ |
| 185 |
|
char *otnm, |
| 186 |
|
int nproc |
| 191 |
|
|
| 192 |
|
ray_init(otnm); /* load the shared scene */ |
| 193 |
|
|
| 191 |
– |
r_send_next = 0; /* set up queue */ |
| 192 |
– |
r_recv_first = r_recv_next = RAYQLEN; |
| 193 |
– |
|
| 194 |
|
ray_popen(nproc); /* fork children */ |
| 195 |
|
} |
| 196 |
|
|
| 230 |
|
} |
| 231 |
|
|
| 232 |
|
|
| 233 |
< |
extern void |
| 233 |
> |
void |
| 234 |
|
ray_psend( /* add a ray to our send queue */ |
| 235 |
|
RAY *r |
| 236 |
|
) |
| 245 |
|
} |
| 246 |
|
|
| 247 |
|
|
| 248 |
< |
extern int |
| 248 |
> |
int |
| 249 |
|
ray_pqueue( /* queue a ray for computation */ |
| 250 |
|
RAY *r |
| 251 |
|
) |
| 274 |
|
} |
| 275 |
|
|
| 276 |
|
|
| 277 |
< |
extern int |
| 277 |
> |
int |
| 278 |
|
ray_presult( /* check for a completed ray */ |
| 279 |
|
RAY *r, |
| 280 |
|
int poll |
| 292 |
|
*r = r_queue[r_recv_first++]; |
| 293 |
|
return(1); |
| 294 |
|
} |
| 295 |
+ |
if (poll < 0) /* immediate polling mode? */ |
| 296 |
+ |
return(0); |
| 297 |
+ |
|
| 298 |
|
n = ray_pnprocs - ray_pnidle; /* pending before flush? */ |
| 299 |
|
|
| 300 |
|
if (ray_pflush() < 0) /* send new rays to process */ |
| 314 |
|
if (FD_ISSET(r_proc[pn].fd_recv, &readset) || |
| 315 |
|
FD_ISSET(r_proc[pn].fd_recv, &errset)) |
| 316 |
|
break; |
| 317 |
< |
/* call select if we must */ |
| 317 |
> |
/* call select() if we must */ |
| 318 |
|
if (pn < 0) { |
| 319 |
|
FD_ZERO(&readset); FD_ZERO(&errset); n = 0; |
| 320 |
|
for (pn = ray_pnprocs; pn--; ) { |
| 374 |
|
} |
| 375 |
|
|
| 376 |
|
|
| 377 |
< |
extern void |
| 377 |
> |
void |
| 378 |
|
ray_pdone( /* reap children and free data */ |
| 379 |
|
int freall |
| 380 |
|
) |
| 385 |
|
free((void *)shm_boundary); |
| 386 |
|
shm_boundary = NULL; |
| 387 |
|
} |
| 388 |
+ |
|
| 389 |
|
ray_done(freall); /* free rendering data */ |
| 390 |
|
} |
| 391 |
|
|
| 439 |
|
} |
| 440 |
|
|
| 441 |
|
|
| 442 |
< |
extern void |
| 442 |
> |
void |
| 443 |
|
ray_popen( /* open the specified # processes */ |
| 444 |
|
int nadd |
| 445 |
|
) |
| 489 |
|
} |
| 490 |
|
|
| 491 |
|
|
| 492 |
< |
extern void |
| 492 |
> |
void |
| 493 |
|
ray_pclose( /* close one or more child processes */ |
| 494 |
|
int nsub |
| 495 |
|
) |
| 506 |
|
/* clear our ray queue */ |
| 507 |
|
while (ray_presult(&res,0) > 0) |
| 508 |
|
; |
| 509 |
+ |
r_send_next = 0; /* hard reset in case of error */ |
| 510 |
+ |
r_recv_first = r_recv_next = RAYQLEN; |
| 511 |
|
/* clean up children */ |
| 512 |
|
while (nsub--) { |
| 513 |
|
int status; |
| 525 |
|
ray_pnidle--; |
| 526 |
|
} |
| 527 |
|
inclose--; |
| 522 |
– |
} |
| 523 |
– |
|
| 524 |
– |
|
| 525 |
– |
void |
| 526 |
– |
quit(ec) /* make sure exit is called */ |
| 527 |
– |
int ec; |
| 528 |
– |
{ |
| 529 |
– |
if (ray_pnprocs > 0) /* close children if any */ |
| 530 |
– |
ray_pclose(0); |
| 531 |
– |
exit(ec); |
| 528 |
|
} |
