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.23 by greg, Wed Aug 4 13:20:45 1993 UTC vs.
Revision 2.28 by greg, Tue Oct 19 16:02:39 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 40 | Line 39 | char *argv[];
39		#endif
40		#endif
41		/* protection from SYSV signals(!) */
42	<	#if defined(sgi) || defined(hpux)
42	>	#if defined(sgi)
43		#define guard_io()      sighold(SIGALRM)
44		#define unguard()       sigrelse(SIGALRM)
45		#endif
#	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],
152	<	O_RDWR|O_CREAT, 0666)) < 0) {
151	>	if ((syncfp =
152	>	fdopen(open(argv[++i],O_RDWR|O_CREAT,0666),"r+")) == NULL) {
153		fprintf(stderr, "%s: cannot open\n",
154		argv[i]);
155		exit(1);
#	Line 174 | Line 182 | char  *argv[];
182		}
183
184
185	+	dolock(fd, ltyp)                /* lock or unlock a file */
186	+	int  fd;
187	+	int  ltyp;
188	+	{
189	+	static struct flock  fls;       /* static so initialized to zeroes */
190	+	extern char  *sys_errlist[];
191	+
192	+	fls.l_type = ltyp;
193	+	if (fcntl(fd, F_SETLKW, &fls) < 0) {
194	+	fprintf(stderr, "%s: cannot lock/unlock file: %s\n",
195	+	progname, sys_errlist[errno]);
196	+	exit(1);
197	+	}
198	+	}
199	+
200	+
201		init(ac, av)                    /* set up output file and start rpict */
202		int  ac;
203		char  **av;
#	Line 188 | Line 212 | char  **av;
212		fprintf(stderr, "%s: %s\n", progname, err);
213		exit(1);
214		}
215	<	if (syncfd != -1) {
216	<	char  buf[32];
217	<	buf[read(syncfd, buf, sizeof(buf)-1)] = '\0';
218	<	sscanf(buf, "%d %d", &hmult, &vmult);
215	>	if (syncfp != NULL) {
216	>	sflock(F_RDLCK);
217	>	fscanf(syncfp, "%d %d", &hmult, &vmult);
218	>	sflock(F_UNLCK);
219		}
220		/* compute piece size */
221		hres /= hmult;
#	Line 206 | Line 230 | char  **av;
230		rpargv[rpargc] = NULL;
231		/* open output file */
232		if ((outfd = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0666)) >= 0) {
233	+	dolock(outfd, F_WRLCK);
234		if ((fp = fdopen(dup(outfd), "w")) == NULL)
235		goto filerr;
236		printargs(ac, av, fp);          /* write header */
#	Line 219 | Line 244 | char  **av;
244		putc('\n', fp);
245		fprtresolu(hres*hmult, vres*vmult, fp);
246		} else if ((outfd = open(outfile, O_RDWR)) >= 0) {
247	+	dolock(outfd, F_RDLCK);
248		if ((fp = fdopen(dup(outfd), "r+")) == NULL)
249		goto filerr;
250		getheader(fp, NULL, NULL);      /* skip header */
#	Line 236 | Line 262 | char  **av;
262		scanorig = ftell(fp);           /* record position of first scanline */
263		if (fclose(fp) == -1)           /* done with stream i/o */
264		goto filerr;
265	<	#if NFS
240	<	sync();                         /* flush NFS buffers */
241	<	#endif
265	>	dolock(outfd, F_UNLCK);
266		/* start rpict process */
267		if (open_process(rpd, rpargv) <= 0) {
268		fprintf(stderr, "%s: cannot start %s\n", progname, rpargv[0]);
#	Line 266 | Line 290 | int
290		nextpiece(xp, yp)               /* get next piece assignment */
291		int  *xp, *yp;
292		{
269	–	struct flock  fls;
270	–	char  buf[64];
271	–
293		if (gotalrm)                    /* someone wants us to quit */
294		return(0);
295	<	if (syncfd != -1) {             /* use sync file */
296	<	fls.l_type = F_WRLCK;           /* gain exclusive access */
297	<	fls.l_whence = 0;
298	<	fls.l_start = 0L;
299	<	fls.l_len = 0L;
300	<	fcntl(syncfd, F_SETLKW, &fls);
301	<	lseek(syncfd, 0L, 0);
302	<	buf[read(syncfd, buf, sizeof(buf)-1)] = '\0';
303	<	if (sscanf(buf, "%*d %*d %d %d", xp, yp) < 2) {
295	>	if (syncfp != NULL) {           /* use sync file */
296	>	/*
297	>	* So we don't necessarily have to lock and unlock the file
298	>	* multiple times (very slow), we establish an exclusive
299	>	* lock at the beginning on our synchronization file and
300	>	* maintain it in the subroutine rvrpiece().
301	>	*/
302	>	sflock(F_WRLCK);
303	>	fseek(syncfp, 0L, 0);           /* read position */
304	>	if (fscanf(syncfp, "%*d %*d %d %d", xp, yp) < 2) {
305		*xp = hmult-1;
306		*yp = vmult;
307		}
308	+	if (rvrlim == 0)                /* initialize recovery limit */
309	+	rvrlim = *xp*vmult + *yp;
310	+	if (rvrpiece(xp, yp)) {         /* do stragglers first */
311	+	sflock(F_UNLCK);
312	+	return(1);
313	+	}
314		if (--(*yp) < 0) {              /* decrement position */
315		*yp = vmult-1;
316	<	if (--(*xp) < 0) {      /* all done! */
317	<	close(syncfd);
316	>	if (--(*xp) < 0) {      /* all done */
317	>	sflock(F_UNLCK);
318		return(0);
319		}
320		}
321	<	sprintf(buf, "%4d %4d\n%4d %4d\n", hmult, vmult, *xp, *yp);
322	<	lseek(syncfd, 0L, 0);           /* write new position */
323	<	write(syncfd, buf, strlen(buf));
324	<	fls.l_type = F_UNLCK;           /* release sync file */
297	<	fcntl(syncfd, F_SETLKW, &fls);
321	>	fseek(syncfp, 0L, 0);           /* write new position */
322	>	fprintf(syncfp, "%4d %4d\n%4d %4d\n\n", hmult, vmult, *xp, *yp);
323	>	fflush(syncfp);
324	>	sflock(F_UNLCK);                /* release sync file */
325		return(1);
326		}
327	<	if (fgets(buf, sizeof(buf), stdin) == NULL)     /* use stdin */
301	<	return(0);
302	<	if (sscanf(buf, "%d %d", xp, yp) == 2)
303	<	return(1);
304	<	fprintf(stderr, "%s: input format error\n", progname);
305	<	exit(cleanup(1));
327	>	return(scanf("%d %d", xp, yp) == 2);    /* use stdin */
328		}
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 386 | Line 448 | int  xpos, ypos;
448		progname, rpargv[0]);
449		exit(cleanup(1));
450		}
451	+	if (verbose) {                          /* notify caller */
452	+	printf("%d %d begun\n", xpos, ypos);
453	+	fflush(stdout);
454	+	}
455		unguard();
456		/* load new piece into buffer */
457		for (y = 0; y < vr; y++) {
#	Line 418 | Line 484 | int  xpos, ypos;
484		/* lock file section so NFS doesn't mess up */
485		fls.l_whence = 0;
486		fls.l_type = F_WRLCK;
487	<	fcntl(outfd, F_SETLKW, &fls);
487	>	if (fcntl(outfd, F_SETLKW, &fls) < 0)
488	>	filerr("lock");
489		#endif
490		/* write new piece to file */
491		if (lseek(outfd, fls.l_start, 0) == -1)
492	<	goto seekerr;
492	>	filerr("seek");
493		if (hmult == 1) {
494		if (writebuf(outfd, (char *)pbuf,
495		vr*hr*sizeof(COLR)) != vr*hr*sizeof(COLR))
496	<	goto writerr;
496	>	filerr("write");
497		} else
498		for (y = 0; y < vr; y++) {
499		if (writebuf(outfd, (char *)(pbuf+y*hr),
500		hr*sizeof(COLR)) != hr*sizeof(COLR))
501	<	goto writerr;
501	>	filerr("write");
502		if (y < vr-1 && lseek(outfd,
503		(long)(hmult-1)*hr*sizeof(COLR),
504		1) == -1)
505	<	goto seekerr;
505	>	filerr("seek");
506		}
507	+	#if NFS
508	+	fls.l_type = F_UNLCK;           /* release lock */
509	+	if (fcntl(outfd, F_SETLKW, &fls) < 0)
510	+	filerr("lock");
511	+	#endif
512	+	if (syncfp != NULL) {                   /* record what's been done */
513	+	sflock(F_WRLCK);
514	+	fseek(syncfp, 0L, 2);           /* append index */
515	+	fprintf(syncfp, "%4d %4d\n", xpos, ypos);
516	+	fflush(syncfp);
517	+	/*** Unlock not necessary, since
518	+	sflock(F_UNLCK);        _exit() or nextpiece() is next ***/
519	+	}
520		if (verbose) {                          /* notify caller */
521		printf("%d %d done\n", xpos, ypos);
522		fflush(stdout);
523		}
524	<	if (pid == -1) {        /* didn't fork or fork failed */
445	<	#if NFS
446	<	fls.l_type = F_UNLCK;           /* release lock */
447	<	fcntl(outfd, F_SETLKW, &fls);
448	<	#endif
524	>	if (pid == -1)          /* didn't fork or fork failed */
525		return(0);
526	<	}
527	<	_exit(0);               /* else exit child process (releasing lock) */
528	<	seekerr:
529	<	fprintf(stderr, "%s: seek error on file \"%s\"\n", progname, outfile);
530	<	_exit(1);
531	<	writerr:
532	<	fprintf(stderr, "%s: write error on file \"%s\"\n", progname, outfile);
526	>	_exit(0);               /* else exit child process (releasing locks) */
527	>	}
528	>
529	>
530	>	filerr(t)                       /* report file error and exit */
531	>	char  *t;
532	>	{
533	>	extern char  *sys_errlist[];
534	>
535	>	fprintf(stderr, "%s: %s error on file \"%s\": %s\n",
536	>	progname, t, outfile, sys_errlist[errno]);
537		_exit(1);
538		}
539

Diff Legend

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