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

Comparing ray/src/hd/rholo4.c (file contents):
Revision 3.10 by gregl, Mon Dec 1 16:35:35 1997 UTC vs.
Revision 3.39 by greg, Fri Feb 28 05:18:49 2020 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   * Holodeck display process communication
6   */
7  
8   #include "rholo.h"
9   #include "rhdisp.h"
10 + #include "rtprocess.h"
11   #include <sys/uio.h>
12 + #include <string.h>
13  
14   #ifndef HDSUF
15 < #define HDSUF   ".hdisp"
15 > #define HDSUF           ".hdi"
16   #endif
17 + #ifndef SLAVENAME
18 + #define SLAVENAME       "slave"
19 + #endif
20  
21 + #ifndef FNONBLK
22 + #define FNONBLK         O_NONBLOCK
23 + #endif
24 +
25   static int      inp_flags;
26 < static int      dpd[3];
26 > static SUBPROC  dpd = SP_INACTIVE;
27   static FILE     *dpout;
28  
29 + static void disp_flush(void);
30 + static void disp_result(int type, int nbytes, char *p);
31  
32 < disp_open(dname)                /* open the named display driver */
33 < char    *dname;
32 >
33 > void
34 > disp_open(              /* open the named display driver */
35 >        char    *dname
36 > )
37   {
38 <        char    dpath[128], *com[3];
39 <        int     i;
38 >        char    buf[sizeof(HDGRID)+512], fd0[8], fd1[8], *cmd[5], *sfn;
39 >        int     i, n, len;
40  
41 +        if (!strcmp(dname, SLAVENAME)) {
42 +                dpd.r = 0;              /* read from stdin */
43 +                dpout = stdout;         /* write to stdout */
44 +                dpd.flags = 0;          /* we're the slave procees */
45 +        } else {
46 +                                        /* get full display program name */
47   #ifdef DEVPATH
48 <        sprintf(dpath, "%s/%s%s", DEVPATH, dname, HDSUF);
48 >                sprintf(buf, "%s/%s%s", DEVPATH, dname, HDSUF);
49   #else
50 <        sprintf(dpath, "dev/%s%s", dname, HDSUF);
50 >                sprintf(buf, "dev/%s%s", dname, HDSUF);
51   #endif
52 <        com[0] = dpath; com[1] = froot; com[2] = NULL;
53 <        i = open_process(dpd, com);
54 <        if (i <= 0)
55 <                error(USER, "cannot start display process");
56 <        if ((dpout = fdopen(dup(dpd[1]), "w")) == NULL)
57 <                error(SYSTEM, "cannot associate FILE with display pipe");
52 >                                        /* dup stdin and stdout */
53 >                if (readinp)
54 >                        sprintf(fd0, "%d", dup(0));
55 >                else
56 >                        strcpy(fd0, "-1");
57 >                sprintf(fd1, "%d", dup(1));
58 >                                        /* start the display process */
59 >                cmd[0] = buf;
60 >                cmd[1] = froot; cmd[2] = fd1; cmd[3] = fd0;
61 >                cmd[4] = NULL;
62 >                i = open_process(&dpd, cmd);
63 >                if (i <= 0)
64 >                        error(USER, "cannot start display process");
65 >                if ((dpout = fdopen(dpd.w, "w")) == NULL)
66 >                        error(SYSTEM, "problem opening display pipe");
67 >                                        /* close dup'ed stdin and stdout */
68 >                if (readinp)
69 >                        close(atoi(fd0));
70 >                close(atoi(fd1));
71 >        }
72 >        dpd.w = -1;             /* causes ignored error in close_process() */
73          inp_flags = 0;
74 <                                /* write out hologram grids */
75 <        for (i = 0; hdlist[i] != NULL; i++)
76 <                disp_result(DS_ADDHOLO, sizeof(HDGRID), (char *)hdlist[i]);
74 >                                /* check if outside */
75 >        if (vdef(OBSTRUCTIONS) && vbool(OBSTRUCTIONS))
76 >                disp_result(DS_OUTSECT, 0, NULL);
77 >                                /* send eye separation if specified */
78 >        if (vdef(EYESEP)) {
79 >                sprintf(buf, "%.9e", vflt(EYESEP));
80 >                disp_result(DS_EYESEP, strlen(buf)+1, buf);
81 >        }
82 >                                /* write out hologram grids & octrees */
83 >        for (i = 0; hdlist[i] != NULL; i++) {
84 >                memcpy(buf, (void *)hdlist[i], sizeof(HDGRID));
85 >                len = sizeof(HDGRID);
86 >                n = vdef(GEOMETRY);
87 >                sfn = i<n ? nvalue(GEOMETRY,i) :
88 >                                n ? nvalue(GEOMETRY,n-1) : vval(OCTREE);
89 >                strcpy(buf+len, sfn);
90 >                len += strlen(sfn) + 1;
91 >                n = vdef(PORTS);
92 >                sfn = i<n ? nvalue(PORTS,i) : n ? nvalue(PORTS,n-1) : "";
93 >                strcpy(buf+len, sfn);
94 >                len += strlen(sfn) + 1;
95 >                disp_result(DS_ADDHOLO, len, buf);
96 >        }
97          disp_flush();
98   }
99  
100  
101 < disp_packet(p)                  /* display a packet */
102 < register PACKHEAD       *p;
101 > void
102 > disp_packet(                    /* display a packet */
103 >        PACKHEAD        *p
104 > )
105   {
106          disp_result(DS_BUNDLE, packsiz(p->nr), (char *)p);
107   }
108  
109  
110 < disp_check(block)               /* check display process */
111 < int     block;
110 > int
111 > disp_check(             /* check display process */
112 >        int     block
113 > )
114   {
115          MSGHEAD msg;
116          int     n;
# Line 67 | Line 123 | int    block;
123                                          /* check read blocking */
124          if (block != (inp_flags == 0)) {
125                  inp_flags = block ? 0 : FNONBLK;
126 <                if (fcntl(dpd[0], F_SETFL, inp_flags) < 0)
126 >                if (fcntl(dpd.r, F_SETFL, inp_flags) < 0)
127                          goto fcntlerr;
128          }
129                                          /* read message header */
130 <        n = read(dpd[0], (char *)&msg, sizeof(MSGHEAD));
130 >        n = read(dpd.r, (char *)&msg, sizeof(MSGHEAD));
131          if (n != sizeof(MSGHEAD)) {
132                  if (n >= 0) {
133                          dpout = NULL;
134                          error(USER, "display process died");
135                  }
136 <                if (errno != EAGAIN & errno != EINTR)
136 >                if ((errno != EAGAIN) & (errno != EINTR))
137                          goto readerr;
138                  return(2);              /* acceptable failure */
139          }
140          if (msg.nbytes) {               /* get the message body */
141 +                if (msg.nbytes < 0)
142 +                        error(INTERNAL, "anti-message from display process");
143                  buf = (char *)malloc(msg.nbytes);
144                  if (buf == NULL)
145                          error(SYSTEM, "out of memory in disp_check");
146 <                if (fcntl(dpd[0], F_SETFL, inp_flags=0) < 0)
146 >                if (inp_flags != 0 && fcntl(dpd.r, F_SETFL, inp_flags=0) < 0)
147                          goto fcntlerr;
148 <                if (readbuf(dpd[0], buf, msg.nbytes) != msg.nbytes)
148 >                if (readbuf(dpd.r, buf, msg.nbytes) != msg.nbytes)
149                          goto readerr;
150          }
151          switch (msg.type) {             /* take appropriate action */
152 <        case DR_BUNDLE:
152 >        case DR_BUNDLE:         /* new bundle to calculate */
153                  if (msg.nbytes != sizeof(PACKHEAD))
154                          error(INTERNAL, "bad DR_BUNDLE from display process");
155                  bundle_set(BS_ADD, (PACKHEAD *)buf, 1);
156                  break;
157 <        case DR_NEWSET:
157 >        case DR_NEWSET:         /* new calculation set */
158                  if (msg.nbytes % sizeof(PACKHEAD))
159                          error(INTERNAL, "bad DR_NEWSET from display process");
160 <                disp_result(DS_STARTIMM, 0, NULL);
160 >                if (msg.nbytes)
161 >                        disp_result(DS_STARTIMM, 0, NULL);
162                  bundle_set(BS_NEW, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
163 <                disp_result(DS_ENDIMM, 0, NULL);
164 <                disp_flush();
163 >                if (msg.nbytes) {
164 >                        disp_result(DS_ENDIMM, 0, NULL);
165 >                        disp_flush();
166 >                }
167                  break;
168 <        case DR_ADDSET:
168 >        case DR_ADDSET:         /* add to calculation set */
169 >                if (!msg.nbytes)
170 >                        break;
171                  if (msg.nbytes % sizeof(PACKHEAD))
172                          error(INTERNAL, "bad DR_ADDSET from display process");
173                  disp_result(DS_STARTIMM, 0, NULL);
174                  bundle_set(BS_ADD, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
175                  disp_result(DS_ENDIMM, 0, NULL);
176 <                disp_check(0);          /* hack -- delete usu. follows add */
176 >                disp_flush();
177                  break;
178 <        case DR_ADJSET:
178 >        case DR_ADJSET:         /* adjust calculation set members */
179 >                if (!msg.nbytes)
180 >                        break;
181                  if (msg.nbytes % sizeof(PACKHEAD))
182                          error(INTERNAL, "bad DR_ADJSET from display process");
183                  disp_result(DS_STARTIMM, 0, NULL);
# Line 120 | Line 185 | int    block;
185                  disp_result(DS_ENDIMM, 0, NULL);
186                  disp_flush();
187                  break;
188 <        case DR_DELSET:
188 >        case DR_DELSET:         /* delete from calculation set */
189 >                if (!msg.nbytes)
190 >                        break;
191                  if (msg.nbytes % sizeof(PACKHEAD))
192                          error(INTERNAL, "bad DR_DELSET from display process");
193                  bundle_set(BS_DEL, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
194                  break;
195 <        case DR_ATTEN:
195 >        case DR_VIEWPOINT:      /* set target eye position */
196 >                if (msg.nbytes != sizeof(VIEWPOINT))
197 >                        error(INTERNAL, "bad DR_VIEWPOINT from display process");
198 >                myeye = *((VIEWPOINT *)buf);
199 >                break;
200 >        case DR_ATTEN:          /* block for priority request */
201                  if (msg.nbytes)
202                          error(INTERNAL, "bad DR_ATTEN from display process");
203                                          /* send acknowledgement */
204                  disp_result(DS_ACKNOW, 0, NULL);
205                  return(disp_check(1));  /* block on following request */
206 <        case DR_SHUTDOWN:
206 >        case DR_KILL:           /* kill computation process(es) */
207                  if (msg.nbytes)
208 +                        error(INTERNAL, "bad DR_KILL from display process");
209 +                if (nprocs > 0)
210 +                        done_rtrace();
211 +                else
212 +                        error(WARNING, "no rtrace process to kill");
213 +                break;
214 +        case DR_RESTART:        /* restart computation process(es) */
215 +                if (msg.nbytes)
216 +                        error(INTERNAL, "bad DR_RESTART from display process");
217 +                if (ncprocs > nprocs)
218 +                        new_rtrace();
219 +                else if (nprocs > 0)
220 +                        error(WARNING, "rtrace already runnning");
221 +                else
222 +                        error(WARNING, "holodeck not open for writing");
223 +                break;
224 +        case DR_CLOBBER:        /* clobber holodeck */
225 +                if (msg.nbytes)
226 +                        error(INTERNAL, "bad DR_CLOBBER from display process");
227 +                if ((force <= 0) | (ncprocs <= 0))
228 +                        error(WARNING, "request to clobber holodeck denied");
229 +                else {
230 +                        error(WARNING, "clobbering holodeck contents");
231 +                        hdclobber(NULL);
232 +                }
233 +                break;
234 +        case DR_SHUTDOWN:       /* shut down program */
235 +                if (msg.nbytes)
236                          error(INTERNAL, "bad DR_SHUTDOWN from display process");
237                  return(0);              /* zero return signals shutdown */
238 <        case DR_NOOP:
238 >        case DR_NOOP:           /* do nothing */
239                  break;
240          default:
241                  error(INTERNAL, "unrecognized request from display process");
# Line 147 | Line 247 | fcntlerr:
247          error(SYSTEM, "cannot change display blocking mode");
248   readerr:
249          error(SYSTEM, "error reading from display process");
250 +        return -1; /* pro forma return */
251   }
252  
253  
254   int
255 < disp_close()                    /* close our display process */
255 > disp_close(void)                        /* close our display process */
256   {
156 –        int     rval;
157 –
257          if (dpout == NULL)
258                  return(-1);
259 +        myeye.rng = 0;
260          disp_result(DS_SHUTDOWN, 0, NULL);
261          fclose(dpout);
262          dpout = NULL;
263 <        return(close_process(dpd));
263 >        return(dpd.flags&PF_RUNNING ? close_process(&dpd) : 0);
264 >
265   }
266  
267  
268 < disp_result(type, nbytes, p)    /* queue result message to display process */
269 < int     type, nbytes;
270 < char    *p;
268 > static void
269 > disp_result(    /* queue result message to display process */
270 >        int     type,
271 >        int     nbytes,
272 >        char    *p
273 > )
274   {
275          MSGHEAD msg;
276 <
276 >                                        /* consistency checks */
277 > #ifdef DEBUG
278 >        if (nbytes < 0 || nbytes > 0 & p == NULL)
279 >                error(CONSISTENCY, "bad buffer handed to disp_result");
280 > #endif
281          if (dpout == NULL)
282                  return;
283          msg.type = type;
284          msg.nbytes = nbytes;
285 <        fwrite((char *)&msg, sizeof(MSGHEAD), 1, dpout);
285 >        putbinary(&msg, sizeof(MSGHEAD), 1, dpout);
286          if (nbytes > 0)
287 <                fwrite(p, 1, nbytes, dpout);
287 >                putbinary(p, 1, nbytes, dpout);
288   }
289  
290  
291 < disp_flush()                    /* flush output to display */
291 > static void
292 > disp_flush(void)                        /* flush output to display */
293   {
294          if (fflush(dpout) < 0)
295                  error(SYSTEM, "error writing to the display process");

Diff Legend

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