ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/Development/ray/src/hd/rholo2l.c
(Generate patch)

Comparing ray/src/hd/rholo2l.c (file contents):
Revision 3.9 by gregl, Fri Dec 12 11:13:17 1997 UTC vs.
Revision 3.15 by schorsch, Sun Jul 27 22:12:02 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1997 Silicon Graphics, Inc. */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ SGI";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * Routines for local rtrace execution
6   */
7  
8 + #include <signal.h>
9 + #include <sys/time.h>
10 + #include <string.h>
11 +
12   #include "rholo.h"
13   #include "random.h"
14   #include "paths.h"
15   #include "selcall.h"
16 < #include <signal.h>
16 < #include <sys/time.h>
16 > #include "rtprocess.h"
17  
18   #ifndef MAXPROC
19   #define MAXPROC         64
# Line 23 | Line 23 | int    nprocs = 0;                             /* running process count */
23  
24   static char     pfile[] = TEMPLATE;             /* persist file name */
25  
26 < static int      rtpd[MAXPROC][3];               /* process descriptors */
26 > static SUBPROC  rtpd[MAXPROC];          /* process descriptors */
27   static float    *rtbuf = NULL;                  /* allocated i/o buffer */
28   static int      maxqlen = 0;                    /* maximum packets per queue */
29  
# Line 38 | Line 38 | start_rtrace()                 /* start rtrace process */
38          int     rmaxpack = 0;
39          int     psiz, n;
40                                          /* get number of processes */
41 <        if (ncprocs <= 0)
41 >        if (ncprocs <= 0 || nprocs > 0)
42                  return(0);
43          if (ncprocs > MAXPROC) {
44                  sprintf(errmsg,
# Line 69 | Line 69 | start_rtrace()                 /* start rtrace process */
69          }
70          maxqlen = 0;
71          for (nprocs = 0; nprocs < ncprocs; nprocs++) {  /* spawn children */
72 <                psiz = open_process(rtpd[nprocs], rtargv);
72 >                psiz = open_process(&rtpd[nprocs], rtargv);
73                  if (psiz <= 0)
74                          error(SYSTEM, "cannot start rtrace process");
75                  n = psiz/(RPACKSIZ*6*sizeof(float));
# Line 77 | Line 77 | start_rtrace()                 /* start rtrace process */
77                          if (!(maxqlen = n))
78                                  error(INTERNAL,
79                                          "bad pipe buffer size assumption");
80 +                        sleep(2);
81                  } else if (n != maxqlen)
82                          error(INTERNAL, "varying pipe buffer size!");
83                  rmaxpack += n;
# Line 136 | Line 137 | register PACKET        *p;
137                                  /* write out the packet */
138          packrays(rtbuf, p);
139          if ((n = p->nr) < RPACKSIZ)     /* add flush block? */
140 <                bzero((char *)(rtbuf+6*n++), 6*sizeof(float));
141 <        if (writebuf(rtpd[pn][1], (char *)rtbuf, 6*sizeof(float)*n) < 0)
140 >                memset((char *)(rtbuf+6*n++), '\0', 6*sizeof(float));
141 >        if (writebuf(rtpd[pn].w, (char *)rtbuf, 6*sizeof(float)*n) < 0)
142                  error(SYSTEM, "write error in queue_packet");
143          p->next = NULL;
144          if (!pqlen[pn]++)       /* add it to the end of the queue */
# Line 166 | Line 167 | int    poll;
167          FD_ZERO(&readset); FD_ZERO(&errset); n = 0;
168          for (pn = nprocs; pn--; ) {
169                  if (pqlen[pn])
170 <                        FD_SET(rtpd[pn][0], &readset);
171 <                FD_SET(rtpd[pn][0], &errset);
172 <                if (rtpd[pn][0] >= n)
173 <                        n = rtpd[pn][0] + 1;
170 >                        FD_SET(rtpd[pn].r, &readset);
171 >                FD_SET(rtpd[pn].r, &errset);
172 >                if (rtpd[pn].r >= n)
173 >                        n = rtpd[pn].r + 1;
174          }
175                                          /* make the call */
176          n = select(n, &readset, (fd_set *)NULL, &errset,
# Line 183 | Line 184 | int    poll;
184                  return(NULL);
185                                          /* make read call(s) */
186          for (pn = 0; pn < nprocs; pn++) {
187 <                if (!FD_ISSET(rtpd[pn][0], &readset) &&
188 <                                !FD_ISSET(rtpd[pn][0], &errset))
187 >                if (!FD_ISSET(rtpd[pn].r, &readset) &&
188 >                                !FD_ISSET(rtpd[pn].r, &errset))
189                          continue;
190          reread:
191 <                n = read(rtpd[pn][0], (char *)rtbuf,
191 >                n = read(rtpd[pn].r, (char *)rtbuf,
192                                  4*sizeof(float)*RPACKSIZ*pqlen[pn]);
193                  if (n < 0) {
194 <                        if (errno == EINTR | errno == EAGAIN)
194 >                        if ((errno == EINTR) | (errno == EAGAIN))
195                                  goto reread;
196                          error(SYSTEM, "read error in get_packets");
197                  }
# Line 202 | Line 203 | int    poll;
203                                  nr++;                   /* add flush block */
204                          n -= 4*sizeof(float)*nr;
205                          if (n < 0) {                    /* get remainder */
206 <                                n += readbuf(rtpd[pn][0],
206 >                                n += readbuf(rtpd[pn].r,
207                                                  (char *)(bp+4*nr)+n, -n);
208                                  if (n)
209                                          goto eoferr;
# Line 269 | Line 270 | flush_queue()                  /* empty all rtrace queues */
270                                  if (rpl->nr < RPACKSIZ)
271                                          nr++;           /* add flush block */
272                          }
273 <                        n = readbuf(rtpd[i][0], (char *)rtbuf,
273 >                        n = readbuf(rtpd[i].r, (char *)rtbuf,
274                                          4*sizeof(float)*nr);
275                          if (n < 0)
276                                  error(SYSTEM, "read failure in flush_queue");
# Line 313 | Line 314 | end_rtrace()                   /* close rtrace process(es) */
314          if (nprocs > 1)
315                  killpersist();
316          while (nprocs > 0) {
317 <                rv = close_process(rtpd[--nprocs]);
317 >                rv = close_process(&rtpd[--nprocs]);
318                  if (rv > 0)
319                          status = rv;
320          }
321 <        free((char *)rtbuf);
321 >        free((void *)rtbuf);
322          rtbuf = NULL;
323          maxqlen = 0;
324          return(status);

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines