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

Comparing ray/src/rt/raypwin.c (file contents):
Revision 2.1 by greg, Fri Feb 8 18:27:31 2008 UTC vs.
Revision 2.9 by greg, Tue Jan 8 00:16:31 2019 UTC

# Line 13 | Line 13 | static const char RCSid[] = "$Id$";
13   * See raypcalls.c for an explanation of these routines.
14   */
15  
16 < /***** XXX CURRENTLY, THIS IS JUST A COLLECTION OF FATAL STUBS XXX *****/
16 > /***** XXX CURRENTLY, THIS IS JUST A COLLECTION OF IMPOTENT STUBS XXX *****/
17  
18   #include  "ray.h"
19  
20 + int             ray_pnprocs = 0;        /* number of child processes */
21 + int             ray_pnidle = 0;         /* number of idle children */
22  
23 < extern void
23 > static RAY      queued_ray;
24 >
25 > void
26   ray_pinit(              /* initialize ray-tracing processes */
27          char    *otnm,
28          int     nproc
29   )
30   {
31 <        error(CONSISTENCY, "parallel ray processing unimplemented");
31 >        ray_pdone(0);
32 >        ray_init(otnm);
33 >        ray_popen(nproc);
34   }
35  
36  
37 < extern void
37 > int
38   ray_psend(                      /* add a ray to our send queue */
39          RAY     *r
40   )
41   {
42 <        error(CONSISTENCY, "parallel ray processing unimplemented");
42 >        if (r == NULL)
43 >                return(0);
44 >        if (ray_pnidle <= 0)
45 >                return(0);
46 >        queued_ray = *r;
47 >        ray_pnidle = 0;
48 >        return(1);
49   }
50  
51  
52 < extern int
52 > int
53   ray_pqueue(                     /* queue a ray for computation */
54          RAY     *r
55   )
56   {
57 <        return(0);
57 >        RNUMBER rno;
58 >
59 >        if (r == NULL)
60 >                return(0);
61 >        if (ray_pnidle <= 0) {
62 >                RAY     new_ray = *r;
63 >                *r = queued_ray;
64 >                queued_ray = new_ray;
65 >        }
66 >        rno = r->rno;
67 >        r->rno = raynum++;
68 >        samplendx++;
69 >        rayvalue(r);
70 >        r->rno = rno;
71 >        return(1);
72   }
73  
74  
75 < extern int
75 > int
76   ray_presult(            /* check for a completed ray */
77          RAY     *r,
78          int     poll
79   )
80   {
81 <        return(-1);
81 >        if (r == NULL)
82 >                return(0);
83 >        if (ray_pnidle <= 0) {
84 >                *r = queued_ray;
85 >                r->rno = raynum++;
86 >                samplendx++;
87 >                rayvalue(r);
88 >                r->rno = queued_ray.rno;
89 >                ray_pnidle = 1;
90 >                return(1);
91 >        }
92 >        return(0);
93   }
94  
95  
96 < extern void
96 > void
97   ray_pdone(              /* reap children and free data */
98          int     freall
99   )
100   {
101 +        ray_done(freall);
102 +        ray_pnprocs = ray_pnidle = 0;
103   }
104  
105  
106 < extern void
106 > void
107   ray_popen(                      /* open the specified # processes */
108          int     nadd
109   )
110   {
111 <        error(CONSISTENCY, "parallel ray processing unimplemented");
111 >        if (ray_pnprocs + nadd > 1) {
112 >                error(WARNING, "only single process supported");
113 >                nadd = 1 - ray_pnprocs;
114 >        }
115 >        ray_pnprocs += nadd;
116 >        ray_pnidle += nadd;
117   }
118  
119  
120 < extern void
120 > void
121   ray_pclose(             /* close one or more child processes */
122          int     nsub
123   )
124   {
125 < }
126 <
127 <
128 < void
129 < quit(ec)                        /* make sure exit is called */
86 < int     ec;
87 < {
88 <        exit(ec);
125 >        if ((nsub <= 0) | (nsub > ray_pnprocs))
126 >                nsub = ray_pnprocs;
127 >        ray_pnprocs -= nsub;
128 >        if ((ray_pnidle -= nsub) < 0)
129 >                ray_pnidle = 0;
130   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines (old)
> Changed lines (new)