ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/RtraceSimulManager.cpp
(Generate patch)

Comparing ray/src/rt/RtraceSimulManager.cpp (file contents):
Revision 2.12 by greg, Sat Aug 3 01:54:46 2024 UTC vs.
Revision 2.22 by greg, Wed Nov 13 02:43:51 2024 UTC

# Line 26 | Line 26 | RadSimulManager::LoadOctree(const char *octn)
26          if (!octn)              // don't support stdin octree
27                  return false;
28  
29 <        NewHeader(octn);        // load header if we can
29 >        NewHeader(octn);        // get octree header
30          ray_init((char *)octn);
31          return true;
32   }
# Line 46 | Line 46 | add2header(char *str, void *p)
46   // Prepare header from previous input (or clear)
47   // Normally called during octree load
48   bool
49 < RadSimulManager::NewHeader(const char *fname)
49 > RadSimulManager::NewHeader(const char *inspec)
50   {
51 <        if (header) {
52 <                free(header); header = NULL;
51 >        if (hlen) {
52 >                free(header); header = NULL; hlen = 0;
53          }
54 <        if (!fname || fname[0] == '!')
54 >        if (!inspec || !*inspec)
55                  return false;
56 <        FILE    *fp = fopen(fname, "rb");
56 >        if (inspec[0] == '!')           // save command as header?
57 >                return AddHeader(inspec+1);
58 >                                        // attempt to read from file
59 >        FILE    *fp = fopen(inspec, "rb");
60 >        if (!fp) return false;
61          bool    ok = (getheader(fp, add2header, this) >= 0);
62          fclose(fp);
63          return ok;
64   }
65  
66 < // Add a string to header (adds newline if none)
66 > // Add a string to header (adds newline if missing)
67   bool
68   RadSimulManager::AddHeader(const char *str)
69   {
70          if (!str) return false;
71          int     len = strlen(str);
72 <        if (!len || str[0] == '\n') return false;
73 <        int     olen = 0;
74 <        if (header) {
75 <                olen = strlen(header);
76 <                header = (char *)realloc(header, olen+len+2);
77 <        } else
72 >        while (len && (str[len-1] == '\n') | (str[len-1] == '\r'))
73 >                --len;                  // don't copy EOL(s)
74 >        if (!len)
75 >                return false;
76 >        if (hlen)
77 >                header = (char *)realloc(header, hlen+len+2);
78 >        else
79                  header = (char *)malloc(len+2);
80 <        if (!header) return false;
81 <        strcpy(header+olen, str);
82 <        if (str[len-1] != '\n') {
78 <                header[olen+len++] = '\n';
79 <                header[olen+len] = '\0';
80 >        if (!header) {
81 >                hlen = 0;               // XXX should report?
82 >                return false;
83          }
84 +        memcpy(header+hlen, str, len);
85 +        hlen += len;
86 +        header[hlen++] = '\n';          // add single EOL
87 +        header[hlen] = '\0';
88          return true;
89   }
90  
# Line 99 | Line 106 | check_special(const char *s)
106  
107   // Append program line to header
108   bool
109 < RadSimulManager::AddHeader(int ac, const char *av[])
109 > RadSimulManager::AddHeader(int ac, char *av[])
110   {
111          if ((ac <= 0) | !av) return false;
112          int     len = 0;
# Line 108 | Line 115 | RadSimulManager::AddHeader(int ac, const char *av[])
115                  if (!av[n]) return false;
116                  len += strlen(av[n]) + 3;
117          }
118 <        int     hlen = 0;
112 <        if (header) {                   // add to header
113 <                hlen = strlen(header);
118 >        if (hlen)                       // add to header
119                  header = (char *)realloc(header, hlen+len+1);
120 <        } else
120 >        else
121                  header = (char *)malloc(len+1);
122 +
123          for (n = 0; n < ac; n++) {
124                  int     c = check_special(av[n]);
125 <                if (c) {                // need to quote argument?
126 <                        if (c == '"') c = '\'';
125 >                len = strlen(av[n]);
126 >                if (c | !len) {         // need to quote argument?
127 >                        if ((c == '"') | (c == '\n')) c = '\'';
128                          else c = '"';
129                          header[hlen++] = c;
130                          strcpy(header+hlen, av[n]);
131 <                        hlen += strlen(av[n]);
131 >                        hlen += len;
132                          header[hlen++] = c;
133                  } else {
134                          strcpy(header+hlen, av[n]);
135 <                        hlen += strlen(av[n]);
135 >                        hlen += len;
136                  }
137                  header[hlen++] = ' ';
138          }
# Line 134 | Line 141 | RadSimulManager::AddHeader(int ac, const char *av[])
141          return true;
142   }
143  
144 + // Look for specific header keyword, return value
145 + const char *
146 + RadSimulManager::GetHeadStr(const char *key, bool inOK) const
147 + {
148 +        if (!key | !hlen || strchr(key, '\n'))
149 +                return NULL;
150 +        if (inOK)                       // skip leading spaces?
151 +                while (isspace(*key)) key++;
152 +
153 +        const int       klen = strlen(key);
154 +        if (!klen)
155 +                return NULL;
156 +        const char *    cp = header;
157 +        while (*cp) {
158 +                if (inOK) {             // skip leading spaces?
159 +                        while (isspace(*cp) && *cp++ != '\n')
160 +                                ;
161 +                        if (cp[-1] == '\n')
162 +                                continue;
163 +                }
164 +                if (!strncmp(cp, key, klen))
165 +                        return cp+klen; // found it!
166 +
167 +                while (*cp && *cp++ != '\n')
168 +                        ;
169 +        }
170 +        return NULL;
171 + }
172 +
173   // How many processors are available?
174   int
175   RadSimulManager::GetNCores()
# Line 160 | Line 196 | RadSimulManager::SetThreadCount(int nt)
196          return NThreads();
197   }
198  
163 – // Assign ray to subthread (fails if NThreads()<2)
164 – bool
165 – RadSimulManager::SplitRay(RAY *r)
166 – {
167 –        if (!ray_pnprocs || ThreadsAvailable() < 1)
168 –                return false;
169 –
170 –        return (ray_psend(r) > 0);
171 – }
172 –
199   // Process a ray (in subthread), optional result
200 < bool
200 > int
201   RadSimulManager::ProcessRay(RAY *r)
202   {
203          if (!Ready()) return false;
# Line 179 | Line 205 | RadSimulManager::ProcessRay(RAY *r)
205          if (!ray_pnprocs) {     // single-threaded mode?
206                  samplendx++;
207                  rayvalue(r);
208 <                return true;
208 >                return 1;
209          }
210 <        int     rv = ray_pqueue(r);
185 <        if (rv < 0) {
186 <                error(WARNING, "ray tracing process(es) died");
187 <                return false;
188 <        }
189 <        return (rv > 0);
210 >        return ray_pqueue(r);
211   }
212  
213   // Wait for next result (or fail)
# Line 203 | Line 224 | RadSimulManager::WaitResult(RAY *r)
224   int
225   RadSimulManager::Cleanup(bool everything)
226   {
227 +        if (ray_pnprocs < 0)
228 +                return 0;               // skip in child process
229 +        NewHeader();
230          if (!ray_pnprocs)
231                  ray_done(everything);
232          else
# Line 210 | Line 234 | RadSimulManager::Cleanup(bool everything)
234          return 0;
235   }
236  
213 – // How many threads are currently unoccupied?
214 – int
215 – RadSimulManager::ThreadsAvailable() const
216 – {
217 –        if (!ray_pnprocs) return 1;
218 –
219 –        return ray_pnidle;
220 – }
221 –
237   // Global pointer to simulation manager for trace call-back (only one)
238   static const RtraceSimulManager *       ourRTsimMan = NULL;
239  
# Line 240 | Line 255 | RtraceSimulManager::Rfifout(RAY *r)
255   bool
256   RtraceSimulManager::UpdateMode()
257   {
243 –        rtFlags &= RTmask;
258          if (!cookedCall)
259                  rtFlags &= ~RTdoFIFO;
260          if (!traceCall)
# Line 248 | Line 262 | RtraceSimulManager::UpdateMode()
262          if (rtFlags & RTimmIrrad)
263                  rtFlags &= ~RTlimDist;
264  
265 <        int     misMatch = rtFlags ^ curFlags;
265 >        int     misMatch = (rtFlags ^ curFlags) & RTmask;
266                                  // updates based on toggled flags
267 <        if (misMatch & RTtraceSources) {
267 >        if (((misMatch & RTtraceSources) != 0) & (nsources > 0)) {
268 >                int     nt = NThreads();
269 >                if (nt > 1) {
270 >                        if (FlushQueue() < 0)
271 >                                return false;
272 >                        SetThreadCount(1);
273 >                }
274 >                int     sn = nsources;
275                  if (rtFlags & RTtraceSources) {
276 <                        for (int sn = 0; sn < nsources; sn++)
276 >                        srcFollowed.NewBitMap(nsources);
277 >                        while (sn--) {
278 >                                if (source[sn].sflags & SFOLLOW)
279 >                                        continue;
280                                  source[sn].sflags |= SFOLLOW;
281 <                } else          // cannot undo this...
282 <                        rtFlags |= RTtraceSources;
281 >                                srcFollowed.Set(sn);
282 >                        }
283 >                } else {
284 >                        while (sn--)
285 >                                if (srcFollowed.Check(sn))
286 >                                        source[sn].sflags &= ~SFOLLOW;
287 >                        srcFollowed.NewBitMap(0);
288 >                }
289 >                if (nt > 1) SetThreadCount(nt);
290          }
291          if (misMatch & RTdoFIFO && FlushQueue() < 0)
292                  return false;
# Line 333 | Line 364 | RtraceSimulManager::EnqueueBundle(const FVECT orig_dir
364          while (n-- > 0) {               // queue each ray
365                  VCOPY(res.rorg, orig_direc[0]);
366                  VCOPY(res.rdir, orig_direc[1]);
367 +                res.rmax = .0;
368                  orig_direc += 2;
369                  rayorigin(&res, PRIMARY, NULL, NULL);
370                  res.rno = rID0 ? (lastRayID = rID0++) : ++lastRayID;
# Line 349 | Line 381 | RtraceSimulManager::EnqueueBundle(const FVECT orig_dir
381                                  if (ray_fifo_in(&res) < 0)
382                                          return -1;
383                                  sendRes = false;
384 <                        } else
385 <                                sendRes &= ProcessRay(&res);
384 >                        } else {
385 >                                int     rv = ProcessRay(&res);
386 >                                if (rv < 0)
387 >                                        return -1;
388 >                                sendRes &= (rv > 0);
389 >                        }
390                  } else if (ThreadsAvailable() < NThreads() &&
391                                  FlushQueue() < 0)
392                          return -1;

Diff Legend

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