ViewVC Help

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

root/Development/ray/src/util/rpiece.c

Comparing ray/src/util/rpiece.c (file contents):
Revision 2.24 by greg, Fri Aug 6 12:58:43 1993 UTC vs.
Revision 2.25 by greg, Fri Aug 6 17:19:52 1993 UTC

#	Line 9 | Line 9 | static char SCCSid[] = "$SunId$ LBL";
9		*/
10
11		#include "standard.h"
12	–	#include <fcntl.h>
12
13		#ifndef F_SETLKW
14
#	Line 62 | Line 61 | int  hres = 1024, vres = 1024, hmult = 4, vmult = 4;
61		char  *outfile = NULL;
62		int  outfd;
63		long  scanorig;
64	<	int  syncfd = -1;               /* lock file descriptor */
64	>	FILE  *syncfp = NULL;           /* synchronization file pointer */
65	>	int  synclst = F_UNLCK;         /* synchronization file lock status */
66		int  nforked = 0;
67
68	+	#define  sflock(t)      if ((t)!=synclst) dolock(fileno(syncfp),synclst=t)
69	+
70		char  *progname;
71		int  verbose = 0;
72	+	int  rvrlim = -1;
73
74		extern long  lseek(), ftell();
75
#	Line 137 | Line 140 | char  *argv[];
140		break;
141		vmult = atoi(argv[++i]);
142		continue;
143	+	case 'R':               /* recover */
144	+	if (argv[i][2])
145	+	break;
146	+	rvrlim = 0;
147	+	/* fall through */
148		case 'F':               /* syncronization file */
149		if (argv[i][2])
150		break;
151	<	if ((syncfd = open(argv[++i],
144	<	O_RDWR|O_CREAT, 0666)) < 0) {
151	>	if ((syncfp = fopen(argv[++i],"r+")) == NULL) {
152		fprintf(stderr, "%s: cannot open\n",
153		argv[i]);
154		exit(1);
#	Line 174 | Line 181 | char  *argv[];
181		}
182
183
184	+	dolock(fd, ltyp)                /* lock or unlock a file */
185	+	int  fd;
186	+	int  ltyp;
187	+	{
188	+	static struct flock  fls;       /* static so initialized to zeroes */
189	+
190	+	fls.l_type = ltyp;
191	+	if (fcntl(fd, F_SETLKW, &fls) < 0) {
192	+	fprintf(stderr, "%s: cannot lock/unlock file\n", progname);
193	+	exit(1);
194	+	}
195	+	}
196	+
197	+
198		init(ac, av)                    /* set up output file and start rpict */
199		int  ac;
200		char  **av;
#	Line 188 | Line 209 | char  **av;
209		fprintf(stderr, "%s: %s\n", progname, err);
210		exit(1);
211		}
212	<	if (syncfd != -1) {
213	<	char  buf[32];
214	<	buf[read(syncfd, buf, sizeof(buf)-1)] = '\0';
215	<	sscanf(buf, "%d %d", &hmult, &vmult);
212	>	if (syncfp != NULL) {
213	>	sflock(F_RDLCK);
214	>	fscanf(syncfp, "%d %d", &hmult, &vmult);
215	>	sflock(F_UNLCK);
216		}
217		/* compute piece size */
218		hres /= hmult;
#	Line 206 | Line 227 | char  **av;
227		rpargv[rpargc] = NULL;
228		/* open output file */
229		if ((outfd = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0666)) >= 0) {
230	+	dolock(outfd, F_WRLCK);
231		if ((fp = fdopen(dup(outfd), "w")) == NULL)
232		goto filerr;
233		printargs(ac, av, fp);          /* write header */
#	Line 219 | Line 241 | char  **av;
241		putc('\n', fp);
242		fprtresolu(hres*hmult, vres*vmult, fp);
243		} else if ((outfd = open(outfile, O_RDWR)) >= 0) {
244	+	dolock(outfd, F_RDLCK);
245		if ((fp = fdopen(dup(outfd), "r+")) == NULL)
246		goto filerr;
247		getheader(fp, NULL, NULL);      /* skip header */
#	Line 236 | Line 259 | char  **av;
259		scanorig = ftell(fp);           /* record position of first scanline */
260		if (fclose(fp) == -1)           /* done with stream i/o */
261		goto filerr;
262	<	#if NFS
240	<	sync();                         /* flush NFS buffers */
241	<	#endif
262	>	dolock(outfd, F_UNLCK);
263		/* start rpict process */
264		if (open_process(rpd, rpargv) <= 0) {
265		fprintf(stderr, "%s: cannot start %s\n", progname, rpargv[0]);
#	Line 266 | Line 287 | int
287		nextpiece(xp, yp)               /* get next piece assignment */
288		int  *xp, *yp;
289		{
269	–	struct flock  fls;
270	–	char  buf[64];
271	–
290		if (gotalrm)                    /* someone wants us to quit */
291		return(0);
292	<	if (syncfd != -1) {             /* use sync file */
293	<	fls.l_type = F_WRLCK;           /* gain exclusive access */
294	<	fls.l_whence = 0;
295	<	fls.l_start = 0L;
296	<	fls.l_len = 0L;
297	<	fcntl(syncfd, F_SETLKW, &fls);
298	<	lseek(syncfd, 0L, 0);
299	<	buf[read(syncfd, buf, sizeof(buf)-1)] = '\0';
300	<	if (sscanf(buf, "%*d %*d %d %d", xp, yp) < 2) {
292	>	if (syncfp != NULL) {           /* use sync file */
293	>	/*
294	>	* So we don't necessarily have to lock and unlock the file
295	>	* multiple times (very slow), we establish an exclusive
296	>	* lock at the beginning on our synchronization file and
297	>	* maintain it in the subroutine rvrpiece().
298	>	*/
299	>	sflock(F_WRLCK);
300	>	fseek(syncfp, 0L, 0);           /* read position */
301	>	if (fscanf(syncfp, "%*d %*d %d %d", xp, yp) < 2) {
302		*xp = hmult-1;
303		*yp = vmult;
304		}
305	+	if (rvrlim == 0)                /* initialize recovery limit */
306	+	rvrlim = *xp*vmult + *yp;
307	+	if (rvrpiece(xp, yp)) {         /* do stragglers first */
308	+	sflock(F_UNLCK);
309	+	return(1);
310	+	}
311		if (--(*yp) < 0) {              /* decrement position */
312		*yp = vmult-1;
313	<	if (--(*xp) < 0) {      /* all done! */
314	<	close(syncfd);
313	>	if (--(*xp) < 0) {      /* all done */
314	>	sflock(F_UNLCK);
315		return(0);
316		}
317		}
318	<	sprintf(buf, "%4d %4d\n%4d %4d\n", hmult, vmult, *xp, *yp);
319	<	lseek(syncfd, 0L, 0);           /* write new position */
320	<	write(syncfd, buf, strlen(buf));
321	<	fls.l_type = F_UNLCK;           /* release sync file */
297	<	fcntl(syncfd, F_SETLKW, &fls);
318	>	fseek(syncfp, 0L, 0);           /* write new position */
319	>	fprintf(syncfp, "%4d %4d\n%4d %4d\n\n", hmult, vmult, *xp, *yp);
320	>	fflush(syncfp);
321	>	sflock(F_UNLCK);                /* release sync file */
322		return(1);
323		}
324	<	if (fgets(buf, sizeof(buf), stdin) == NULL)     /* use stdin */
301	<	return(0);
302	<	if (sscanf(buf, "%d %d", xp, yp) == 2)
324	>	if (scanf("%d %d", xp, yp) == 2)        /* use stdin */
325		return(1);
326		fprintf(stderr, "%s: input format error\n", progname);
327		exit(cleanup(1));
#	Line 307 | Line 329 | int  *xp, *yp;
329
330
331		int
332	+	rvrpiece(xp, yp)                /* check for recoverable pieces */
333	+	register int  *xp, *yp;
334	+	{
335	+	static char  *pdone = NULL;     /* which pieces are done */
336	+	static long  readpos = -1;      /* how far we've read */
337	+	register int  i;
338	+	/*
339	+	* This routine is called by nextpiece() with an
340	+	* exclusive lock on syncfp and the file pointer at the
341	+	* appropriate position to read in the finished pieces.
342	+	*/
343	+	if (rvrlim < 0)
344	+	return(0);              /* only check if asked */
345	+	if (pdone == NULL)              /* first call */
346	+	pdone = calloc(hmult*vmult, sizeof(char));
347	+	if (readpos != -1)              /* mark what's been done */
348	+	fseek(syncfp, readpos, 0);
349	+	while (fscanf(syncfp, "%d %d", xp, yp) == 2)
350	+	pdone[*xp*vmult+*yp] = 1;
351	+	if (!feof(syncfp)) {
352	+	fprintf(stderr, "%s: format error in sync file\n", progname);
353	+	exit(1);
354	+	}
355	+	readpos = ftell(syncfp);
356	+	i = hmult*vmult;                /* find an unaccounted for piece */
357	+	while (i-- > rvrlim)
358	+	if (!pdone[i]) {
359	+	*xp = i / vmult;
360	+	*yp = i % vmult;
361	+	pdone[i] = 1;   /* consider it done */
362	+	return(1);
363	+	}
364	+	rvrlim = -1;                    /* nothing left to recover */
365	+	free(pdone);
366	+	pdone = NULL;
367	+	return(0);
368	+	}
369	+
370	+
371	+	int
372		cleanup(rstat)                  /* close rpict process and clean up */
373		int  rstat;
374		{
#	Line 441 | Line 503 | int  xpos, ypos;
503		1) == -1)
504		goto seekerr;
505		}
506	+	#if NFS
507	+	fls.l_type = F_UNLCK;           /* release lock */
508	+	fcntl(outfd, F_SETLKW, &fls);
509	+	#endif
510	+	if (syncfp != NULL) {                   /* record what's been done */
511	+	sflock(F_WRLCK);
512	+	fseek(syncfp, 0L, 2);           /* append index */
513	+	fprintf(syncfp, "%4d %4d\n", xpos, ypos);
514	+	fflush(syncfp);
515	+	/*** Unlock not necessary, since
516	+	sflock(F_UNLCK);        _exit() or nextpiece() is next ***/
517	+	}
518		if (verbose) {                          /* notify caller */
519		printf("%d %d done\n", xpos, ypos);
520		fflush(stdout);
521		}
522	<	if (pid == -1) {        /* didn't fork or fork failed */
449	<	#if NFS
450	<	fls.l_type = F_UNLCK;           /* release lock */
451	<	fcntl(outfd, F_SETLKW, &fls);
452	<	#endif
522	>	if (pid == -1)          /* didn't fork or fork failed */
523		return(0);
524	<	}
455	<	_exit(0);               /* else exit child process (releasing lock) */
524	>	_exit(0);               /* else exit child process (releasing locks) */
525		seekerr:
526		fprintf(stderr, "%s: seek error on file \"%s\"\n", progname, outfile);
527		_exit(1);

Diff Legend

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