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

Comparing src/hd/rholo4.c (file contents):
Revision 3.4 by gregl, Thu Nov 6 16:12:41 1997 UTC vs.
Revision 3.14 by gregl, Fri Dec 12 18:12:40 1997 UTC

# Line 18 | Line 18 | static char SCCSid[] = "$SunId$ SGI";
18  
19   static int      inp_flags;
20   static int      dpd[3];
21 < static int      pipesiz;
21 > static FILE     *dpout;
22  
23  
24   disp_open(dname)                /* open the named display driver */
25   char    *dname;
26   {
27 <        char    dpath[128], *com[2];
27 >        char    dpath[128], fd0[8], fd1[8], *cmd[5];
28          int     i;
29 <
29 >                                /* get full display program name */
30   #ifdef DEVPATH
31          sprintf(dpath, "%s/%s%s", DEVPATH, dname, HDSUF);
32   #else
33          sprintf(dpath, "dev/%s%s", dname, HDSUF);
34   #endif
35 <        com[0] = dpath; com[1] = NULL;
36 <        pipesiz = open_process(dpd, com);
37 <        if (pipesiz <= 0)
35 >                                /* dup stdin and stdout */
36 >        if (readinp)
37 >                sprintf(fd0, "%d", dup(0));
38 >        else
39 >                strcpy(fd0, "-1");
40 >        sprintf(fd1, "%d", dup(1));
41 >                                /* start the display process */
42 >        cmd[0] = dpath;
43 >        cmd[1] = froot; cmd[2] = fd1; cmd[3] = fd0;
44 >        cmd[4] = NULL;
45 >        i = open_process(dpd, cmd);
46 >        if (i <= 0)
47                  error(USER, "cannot start display process");
48 +        if ((dpout = fdopen(dpd[1], "w")) == NULL)
49 +                error(SYSTEM, "cannot associate FILE with display pipe");
50 +        dpd[1] = -1;            /* causes ignored error in close_process() */
51          inp_flags = 0;
52 +                                /* close dup'ed stdin and stdout */
53 +        if (readinp)
54 +                close(atoi(fd0));
55 +        close(atoi(fd1));
56                                  /* write out hologram grids */
57          for (i = 0; hdlist[i] != NULL; i++)
58                  disp_result(DS_ADDHOLO, sizeof(HDGRID), (char *)hdlist[i]);
59 +        disp_flush();
60   }
61  
62  
# Line 57 | Line 74 | int    block;
74          int     n;
75          char    *buf = NULL;
76  
77 <        if (pipesiz <= 0)
77 >        if (dpout == NULL)
78                  return(-1);
79 +                                        /* flush display output */
80 +        disp_flush();
81                                          /* check read blocking */
82          if (block != (inp_flags == 0)) {
83                  inp_flags = block ? 0 : FNONBLK;
# Line 68 | Line 87 | int    block;
87                                          /* read message header */
88          n = read(dpd[0], (char *)&msg, sizeof(MSGHEAD));
89          if (n != sizeof(MSGHEAD)) {
90 <                if (n >= 0)
90 >                if (n >= 0) {
91 >                        dpout = NULL;
92                          error(USER, "display process died");
93 +                }
94                  if (errno != EAGAIN & errno != EINTR)
95                          goto readerr;
96                  return(2);              /* acceptable failure */
# Line 84 | Line 105 | int    block;
105                          goto readerr;
106          }
107          switch (msg.type) {             /* take appropriate action */
108 <        case DR_BUNDLE:
108 >        case DR_BUNDLE:         /* new bundle to calculate */
109                  if (msg.nbytes != sizeof(PACKHEAD))
110                          error(INTERNAL, "bad DR_BUNDLE from display process");
111                  bundle_set(BS_ADD, (PACKHEAD *)buf, 1);
112                  break;
113 <        case DR_NEWSET:
113 >        case DR_NEWSET:         /* new calculation set */
114                  if (msg.nbytes % sizeof(PACKHEAD))
115                          error(INTERNAL, "bad DR_NEWSET from display process");
116                  disp_result(DS_STARTIMM, 0, NULL);
117                  bundle_set(BS_NEW, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
118                  disp_result(DS_ENDIMM, 0, NULL);
119 +                disp_flush();
120                  break;
121 <        case DR_ADDSET:
121 >        case DR_ADDSET:         /* add to calculation set */
122                  if (msg.nbytes % sizeof(PACKHEAD))
123                          error(INTERNAL, "bad DR_ADDSET from display process");
124                  disp_result(DS_STARTIMM, 0, NULL);
125                  bundle_set(BS_ADD, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
126                  disp_result(DS_ENDIMM, 0, NULL);
127 +                disp_check(0);          /* hack -- delete usu. follows add */
128                  break;
129 <        case DR_DELSET:
129 >        case DR_ADJSET:         /* adjust calculation set members */
130                  if (msg.nbytes % sizeof(PACKHEAD))
131 +                        error(INTERNAL, "bad DR_ADJSET from display process");
132 +                disp_result(DS_STARTIMM, 0, NULL);
133 +                bundle_set(BS_ADJ, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
134 +                disp_result(DS_ENDIMM, 0, NULL);
135 +                disp_flush();
136 +                break;
137 +        case DR_DELSET:         /* delete from calculation set */
138 +                if (msg.nbytes % sizeof(PACKHEAD))
139                          error(INTERNAL, "bad DR_DELSET from display process");
140                  bundle_set(BS_DEL, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
141                  break;
142 <        case DR_ATTEN:
142 >        case DR_ATTEN:          /* block for priority request */
143                  if (msg.nbytes)
144                          error(INTERNAL, "bad DR_ATTEN from display process");
145                                          /* send acknowledgement */
146                  disp_result(DS_ACKNOW, 0, NULL);
147                  return(disp_check(1));  /* block on following request */
148 <        case DR_SHUTDOWN:
148 >        case DR_KILL:           /* kill computation process(es) */
149                  if (msg.nbytes)
150 +                        error(INTERNAL, "bad DR_KILL from display process");
151 +                if (nprocs > 0)
152 +                        done_rtrace();
153 +                else
154 +                        error(WARNING, "no rtrace process to kill");
155 +                break;
156 +        case DR_RESTART:        /* restart computation process(es) */
157 +                if (msg.nbytes)
158 +                        error(INTERNAL, "bad DR_RESTART from display process");
159 +                if (ncprocs > nprocs)
160 +                        new_rtrace();
161 +                else if (nprocs > 0)
162 +                        error(WARNING, "rtrace already runnning");
163 +                else
164 +                        error(WARNING, "holodeck not open for writing");
165 +                break;
166 +        case DR_CLOBBER:        /* clobber holodeck */
167 +                if (msg.nbytes)
168 +                        error(INTERNAL, "bad DR_CLOBBER from display process");
169 +                if (!force || !ncprocs)
170 +                        error(WARNING, "request to clobber holodeck denied");
171 +                else {
172 +                        error(WARNING, "clobbering holodeck contents");
173 +                        hdclobber(NULL);
174 +                }
175 +                break;
176 +        case DR_SHUTDOWN:       /* shut down program */
177 +                if (msg.nbytes)
178                          error(INTERNAL, "bad DR_SHUTDOWN from display process");
179                  return(0);              /* zero return signals shutdown */
180 +        case DR_NOOP:           /* do nothing */
181 +                break;
182          default:
183                  error(INTERNAL, "unrecognized request from display process");
184          }
# Line 136 | Line 197 | disp_close()                   /* close our display process */
197   {
198          int     rval;
199  
200 <        if (pipesiz <= 0)
200 >        if (dpout == NULL)
201                  return(-1);
202          disp_result(DS_SHUTDOWN, 0, NULL);
203 <        pipesiz = 0;
203 >        fclose(dpout);
204 >        dpout = NULL;
205          return(close_process(dpd));
206   }
207  
208  
209 < disp_result(type, nbytes, p)    /* send result message to display process */
209 > disp_result(type, nbytes, p)    /* queue result message to display process */
210   int     type, nbytes;
211   char    *p;
212   {
151 –        struct iovec    iov[2];
213          MSGHEAD msg;
153 –        int     n;
214  
215 <        if (pipesiz <= 0)
215 >        if (dpout == NULL)
216                  return;
217          msg.type = type;
218          msg.nbytes = nbytes;
219 <        if (nbytes == 0 || sizeof(MSGHEAD)+nbytes > pipesiz) {
220 <                do
221 <                        n = write(dpd[1], (char *)&msg, sizeof(MSGHEAD));
222 <                while (n < 0 && errno == EINTR);
223 <                if (n != sizeof(MSGHEAD))
224 <                        goto writerr;
225 <                if (nbytes > 0 && writebuf(dpd[1], p, nbytes) != nbytes)
226 <                        goto writerr;
227 <                return;
228 <        }
169 <        iov[0].iov_base = (char *)&msg;
170 <        iov[0].iov_len = sizeof(MSGHEAD);
171 <        iov[1].iov_base = p;
172 <        iov[1].iov_len = nbytes;
173 <        do
174 <                n = writev(dpd[1], iov, 2);
175 <        while (n < 0 && errno == EINTR);
176 <        if (n == sizeof(MSGHEAD)+nbytes)
177 <                return;
178 < writerr:
179 <        error(SYSTEM, "write error in disp_result");
219 >        fwrite((char *)&msg, sizeof(MSGHEAD), 1, dpout);
220 >        if (nbytes > 0)
221 >                fwrite(p, 1, nbytes, dpout);
222 > }
223 >
224 >
225 > disp_flush()                    /* flush output to display */
226 > {
227 >        if (fflush(dpout) < 0)
228 >                error(SYSTEM, "error writing to the display process");
229   }

Diff Legend

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