ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/cv/bsdfmesh.c

Comparing ray/src/cv/bsdfmesh.c (file contents):
Revision 2.1 by greg, Fri Oct 19 04:14:29 2012 UTC vs.
Revision 2.2 by greg, Sat Oct 20 07:02:00 2012 UTC

#	Line 23 | Line 23 | int                    nprocs = 1;
23		/* number of children (-1 in child) */
24		static int              nchild = 0;
25
26	+	/* Create a new migration holder (sharing memory for multiprocessing) */
27	+	static MIGRATION *
28	+	new_migration(RBFNODE *from_rbf, RBFNODE *to_rbf)
29	+	{
30	+	size_t          memlen = sizeof(MIGRATION) +
31	+	sizeof(float)*(from_rbf->nrbf*to_rbf->nrbf - 1);
32	+	MIGRATION       *newmig;
33	+	#ifdef _WIN32
34	+	if (nprocs > 1)
35	+	fprintf(stderr, "%s: warning - multiprocessing not supported\n",
36	+	progname);
37	+	nprocs = 1;
38	+	newmig = (MIGRATION *)malloc(memlen);
39	+	#else
40	+	if (nprocs <= 1) {                      /* single process? */
41	+	newmig = (MIGRATION *)malloc(memlen);
42	+	} else {                                /* else need to share memory */
43	+	newmig = (MIGRATION *)mmap(NULL, memlen, PROT_READ|PROT_WRITE,
44	+	MAP_ANON|MAP_SHARED, -1, 0);
45	+	if ((void *)newmig == MAP_FAILED)
46	+	newmig = NULL;
47	+	}
48	+	#endif
49	+	if (newmig == NULL) {
50	+	fprintf(stderr, "%s: cannot allocate new migration\n", progname);
51	+	exit(1);
52	+	}
53	+	newmig->rbfv[0] = from_rbf;
54	+	newmig->rbfv[1] = to_rbf;
55	+	/* insert in edge lists */
56	+	newmig->enxt[0] = from_rbf->ejl;
57	+	from_rbf->ejl = newmig;
58	+	newmig->enxt[1] = to_rbf->ejl;
59	+	to_rbf->ejl = newmig;
60	+	newmig->next = mig_list;                /* push onto global list */
61	+	return(mig_list = newmig);
62	+	}
63	+
64	+	#ifdef _WIN32
65	+	#define await_children(n)       (void)(n)
66	+	#define run_subprocess()        0
67	+	#define end_subprocess()        (void)0
68	+	#else
69	+
70	+	/* Wait for the specified number of child processes to complete */
71	+	static void
72	+	await_children(int n)
73	+	{
74	+	int     exit_status = 0;
75	+
76	+	if (n > nchild)
77	+	n = nchild;
78	+	while (n-- > 0) {
79	+	int     status;
80	+	if (wait(&status) < 0) {
81	+	fprintf(stderr, "%s: missing child(ren)!\n", progname);
82	+	nchild = 0;
83	+	break;
84	+	}
85	+	--nchild;
86	+	if (status) {                   /* something wrong */
87	+	if ((status = WEXITSTATUS(status)))
88	+	exit_status = status;
89	+	else
90	+	exit_status += !exit_status;
91	+	fprintf(stderr, "%s: subprocess died\n", progname);
92	+	n = nchild;             /* wait for the rest */
93	+	}
94	+	}
95	+	if (exit_status)
96	+	exit(exit_status);
97	+	}
98	+
99	+	/* Start child process if multiprocessing selected */
100	+	static pid_t
101	+	run_subprocess(void)
102	+	{
103	+	int     status;
104	+	pid_t   pid;
105	+
106	+	if (nprocs <= 1)                        /* any children requested? */
107	+	return(0);
108	+	await_children(nchild + 1 - nprocs);    /* free up child process */
109	+	if ((pid = fork())) {
110	+	if (pid < 0) {
111	+	fprintf(stderr, "%s: cannot fork subprocess\n",
112	+	progname);
113	+	exit(1);
114	+	}
115	+	++nchild;                       /* subprocess started */
116	+	return(pid);
117	+	}
118	+	nchild = -1;
119	+	return(0);                              /* put child to work */
120	+	}
121	+
122	+	/* If we are in subprocess, call exit */
123	+	#define end_subprocess()        if (nchild < 0) _exit(0); else
124	+
125	+	#endif  /* ! _WIN32 */
126	+
127		/* Compute (and allocate) migration price matrix for optimization */
128		static float *
129		price_routes(const RBFNODE *from_rbf, const RBFNODE *to_rbf)
#	Line 106 | Line 207 | static double
207		migration_step(MIGRATION *mig, double *src_rem, double *dst_rem, const float *pmtx)
208		{
209		const double    maxamt = .1;
210	<	const double    minamt = maxamt*.0001;
210	>	const double    minamt = maxamt*5e-6;
211		static double   *src_cost = NULL;
212		static int      n_alloc = 0;
213		struct {
#	Line 136 | Line 237 | migration_step(MIGRATION *mig, double *src_rem, double
237		for (cur.s = mtx_nrows(mig); cur.s--; ) {
238		const float *price = pmtx + cur.s*mtx_ncols(mig);
239		double      cost_others = 0;
240	<	if (src_rem[cur.s] < minamt)
240	>	if (src_rem[cur.s] <= minamt)
241		continue;
242		cur.d = -1;                         /* examine cheapest dest. */
243		for (i = mtx_ncols(mig); i--; )
#	Line 164 | Line 265 | migration_step(MIGRATION *mig, double *src_rem, double
265		if ((best.s < 0) | (best.d < 0))
266		return(.0);
267		/* make the actual move */
268	<	mig->mtx[mtx_ndx(mig,best.s,best.d)] += best.amt;
268	>	mtx_coef(mig,best.s,best.d) += best.amt;
269		src_rem[best.s] -= best.amt;
270		dst_rem[best.d] -= best.amt;
271		return(best.amt);
#	Line 185 | Line 286 | thetaphi(const FVECT v)
286		}
287		#endif
288
188	–	/* Create a new migration holder (sharing memory for multiprocessing) */
189	–	static MIGRATION *
190	–	new_migration(RBFNODE *from_rbf, RBFNODE *to_rbf)
191	–	{
192	–	size_t          memlen = sizeof(MIGRATION) +
193	–	sizeof(float)*(from_rbf->nrbf*to_rbf->nrbf - 1);
194	–	MIGRATION       *newmig;
195	–	#ifdef _WIN32
196	–	if (nprocs > 1)
197	–	fprintf(stderr, "%s: warning - multiprocessing not supported\n",
198	–	progname);
199	–	nprocs = 1;
200	–	newmig = (MIGRATION *)malloc(memlen);
201	–	#else
202	–	if (nprocs <= 1) {                      /* single process? */
203	–	newmig = (MIGRATION *)malloc(memlen);
204	–	} else {                                /* else need to share memory */
205	–	newmig = (MIGRATION *)mmap(NULL, memlen, PROT_READ|PROT_WRITE,
206	–	MAP_ANON|MAP_SHARED, -1, 0);
207	–	if ((void *)newmig == MAP_FAILED)
208	–	newmig = NULL;
209	–	}
210	–	#endif
211	–	if (newmig == NULL) {
212	–	fprintf(stderr, "%s: cannot allocate new migration\n", progname);
213	–	exit(1);
214	–	}
215	–	newmig->rbfv[0] = from_rbf;
216	–	newmig->rbfv[1] = to_rbf;
217	–	/* insert in edge lists */
218	–	newmig->enxt[0] = from_rbf->ejl;
219	–	from_rbf->ejl = newmig;
220	–	newmig->enxt[1] = to_rbf->ejl;
221	–	to_rbf->ejl = newmig;
222	–	newmig->next = mig_list;                /* push onto global list */
223	–	return(mig_list = newmig);
224	–	}
225	–
226	–	#ifdef _WIN32
227	–	#define await_children(n)       (void)(n)
228	–	#define run_subprocess()        0
229	–	#define end_subprocess()        (void)0
230	–	#else
231	–
232	–	/* Wait for the specified number of child processes to complete */
233	–	static void
234	–	await_children(int n)
235	–	{
236	–	int     exit_status = 0;
237	–
238	–	if (n > nchild)
239	–	n = nchild;
240	–	while (n-- > 0) {
241	–	int     status;
242	–	if (wait(&status) < 0) {
243	–	fprintf(stderr, "%s: missing child(ren)!\n", progname);
244	–	nchild = 0;
245	–	break;
246	–	}
247	–	--nchild;
248	–	if (status) {                   /* something wrong */
249	–	if ((status = WEXITSTATUS(status)))
250	–	exit_status = status;
251	–	else
252	–	exit_status += !exit_status;
253	–	fprintf(stderr, "%s: subprocess died\n", progname);
254	–	n = nchild;             /* wait for the rest */
255	–	}
256	–	}
257	–	if (exit_status)
258	–	exit(exit_status);
259	–	}
260	–
261	–	/* Start child process if multiprocessing selected */
262	–	static pid_t
263	–	run_subprocess(void)
264	–	{
265	–	int     status;
266	–	pid_t   pid;
267	–
268	–	if (nprocs <= 1)                        /* any children requested? */
269	–	return(0);
270	–	await_children(nchild + 1 - nprocs);    /* free up child process */
271	–	if ((pid = fork())) {
272	–	if (pid < 0) {
273	–	fprintf(stderr, "%s: cannot fork subprocess\n",
274	–	progname);
275	–	exit(1);
276	–	}
277	–	++nchild;                       /* subprocess started */
278	–	return(pid);
279	–	}
280	–	nchild = -1;
281	–	return(0);                              /* put child to work */
282	–	}
283	–
284	–	/* If we are in subprocess, call exit */
285	–	#define end_subprocess()        if (nchild < 0) _exit(0); else
286	–
287	–	#endif  /* ! _WIN32 */
288	–
289		/* Compute and insert migration along directed edge (may fork child) */
290		static MIGRATION *
291		create_migration(RBFNODE *from_rbf, RBFNODE *to_rbf)
292		{
293	<	const double    end_thresh = 0.1/(from_rbf->nrbf*to_rbf->nrbf);
294	<	const double    check_thresh = 0.01;
295	<	const double    rel_thresh = 5e-6;
293	>	const double    end_thresh = 5e-6;
294		float           *pmtx;
295		MIGRATION       *newmig;
296		double          *src_rem, *dst_rem;
#	Line 318 | Line 316 | create_migration(RBFNODE *from_rbf, RBFNODE *to_rbf)
316		#ifdef DEBUG
317		fprintf(stderr, "Building path from (theta,phi) %s ",
318		thetaphi(from_rbf->invec));
319	<	fprintf(stderr, "to %s", thetaphi(to_rbf->invec));
320	<	/* if (nchild) */ fputc('\n', stderr);
319	>	fprintf(stderr, "to %s with %d x %d matrix\n",
320	>	thetaphi(to_rbf->invec),
321	>	from_rbf->nrbf, to_rbf->nrbf);
322		#endif
323		/* starting quantities */
324		memset(newmig->mtx, 0, sizeof(float)*from_rbf->nrbf*to_rbf->nrbf);
#	Line 332 | Line 331 | create_migration(RBFNODE *from_rbf, RBFNODE *to_rbf)
331		total_rem -= move_amt;
332		#ifdef DEBUG
333		if (!nchild)
334	<	/* fputc('.', stderr); */
336	<	fprintf(stderr, "%.9f remaining...\r", total_rem);
334	>	fprintf(stderr, "\r%.9f remaining...", total_rem);
335		#endif
336	<	} while (total_rem > end_thresh && (total_rem > check_thresh) |
339	<	(move_amt > rel_thresh*total_rem));
336	>	} while ((total_rem > end_thresh) & (move_amt > 0));
337		#ifdef DEBUG
338	<	if (!nchild) fputs("\ndone.\n", stderr);
338	>	if (!nchild) fputs("done.\n", stderr);
339		else fprintf(stderr, "finished with %.9f remaining\n", total_rem);
340		#endif
341		for (i = from_rbf->nrbf; i--; ) {       /* normalize final matrix */
#	Line 347 | Line 344 | create_migration(RBFNODE *from_rbf, RBFNODE *to_rbf)
344		if (nf <= FTINY) continue;
345		nf = from_rbf->vtotal / nf;
346		for (j = to_rbf->nrbf; j--; )
347	<	newmig->mtx[mtx_ndx(newmig,i,j)] *= nf;
347	>	mtx_coef(newmig,i,j) *= nf;
348		}
349		end_subprocess();                       /* exit here if subprocess */
350		free(pmtx);                             /* free working arrays */

Diff Legend

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