ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/ranimate.c
(Generate patch)

Comparing ray/src/util/ranimate.c (file contents):
Revision 2.1 by greg, Fri Jan 12 12:16:17 1996 UTC vs.
Revision 2.6 by greg, Tue Jan 23 17:01:33 1996 UTC

# Line 9 | Line 9 | static char SCCSid[] = "$SunId$ LBL";
9   */
10  
11   #include "standard.h"
12 + #include <ctype.h>
13   #include <sys/types.h>
14   #include <sys/stat.h>
15   #include "view.h"
16   #include "vars.h"
17 + #include "netproc.h"
18                                  /* input variables */
19   #define HOST            0               /* rendering host machine */
20   #define RENDER          1               /* rendering options */
# Line 55 | Line 57 | VARIABLE       vv[] = {                /* variable-value pairs */
57          {"ANIMATE",     2,      0,      NULL,   onevalue},
58          {"TRANSFER",    2,      0,      NULL,   onevalue},
59          {"ARCHIVE",     2,      0,      NULL,   onevalue},
60 <        {"INTERP",      3,      0,      NULL,   intvalue},
61 <        {"OVERSAMP",    2,      0,      NULL,   fltvalue},
60 >        {"INTERPOLATE", 3,      0,      NULL,   intvalue},
61 >        {"OVERSAMPLE",  2,      0,      NULL,   fltvalue},
62          {"MBLUR",       2,      0,      NULL,   onevalue},
63          {"RTRACE",      2,      0,      NULL,   boolvalue},
64          {"DISKSPACE",   3,      0,      NULL,   fltvalue},
# Line 87 | Line 89 | char   rresopt[32];            /* rendering resolution options */
89   char    fresopt[32];            /* filter resolution options */
90   int     pfiltalways;            /* always use pfilt? */
91  
92 + struct pslot {
93 +        int     pid;                    /* process ID (0 if empty) */
94 +        int     fout;                   /* output frame number */
95 +        int     (*rcvf)();              /* recover function */
96 + }       *pslot;                 /* process slots */
97 + int     npslots;                /* number of process slots */
98 +
99 + int     lastpid;                /* ID of last completed background process */
100 + PSERVER *lastpserver;           /* last process server used */
101 +
102 + #define phostname(ps)   ((ps)->hostname[0] ? (ps)->hostname : astat.host)
103 +
104 + struct pslot    *findpslot();
105 +
106   VIEW    *getview();
107   char    *getexp();
108  
# Line 138 | Line 154 | char   *argv[];
154                                                  /* print variables */
155          if (explicate)
156                  printvars(stdout);
157 +                                                /* set up process servers */
158 +        sethosts();
159                                                  /* run animation */
160          animate();
161                                                  /* all done */
# Line 145 | Line 163 | char   *argv[];
163                  argv[i] = vval(NEXTANIM);       /* just change input file */
164                  if (!silent)
165                          printargs(argc, argv, stdout);
166 <                if (!noaction) {
167 <                        execvp(progname, argv);         /* pass to next */
150 <                        quit(1);                        /* shouldn't return */
151 <                }
166 >                execvp(progname, argv);         /* pass to next */
167 >                quit(1);                        /* shouldn't return */
168          }
169          quit(0);
170   userr:
# Line 222 | Line 238 | putastat()                     /* put out current status */
238          char    buf[256];
239          FILE    *fp;
240  
241 +        if (noaction)
242 +                return;
243          sprintf(buf, "%s/%s", vval(DIRECTORY), SFNAME);
244          if ((fp = fopen(buf, "w")) == NULL) {
245                  perror(buf);
# Line 263 | Line 281 | setdefaults()                  /* set default values */
281   {
282          char    buf[256];
283  
284 <        if (vdef(OCTREE) == vdef(ANIMATE)) {
284 >        if (vdef(ANIMATE)) {
285 >                vval(OCTREE) = NULL;
286 >                vdef(OCTREE) = 0;
287 >        } else if (!vdef(OCTREE)) {
288                  fprintf(stderr, "%s: either %s or %s must be defined\n",
289                                  progname, vnam(OCTREE), vnam(ANIMATE));
290                  quit(1);
# Line 272 | Line 293 | setdefaults()                  /* set default values */
293                  fprintf(stderr, "%s: %s undefined\n", progname, vnam(VIEWFILE));
294                  quit(1);
295          }
296 +        if (!vdef(HOST)) {
297 +                vval(HOST) = LHOSTNAME;
298 +                vdef(HOST)++;
299 +        }
300          if (!vdef(START)) {
301                  vval(START) = "1";
302                  vdef(START)++;
303          }
304          if (!vdef(END)) {
305 <                sprintf(buf, "%d", countviews());
305 >                sprintf(buf, "%d", countviews()+vint(START)-1);
306                  vval(END) = savqstr(buf);
307                  vdef(END)++;
308          }
309 +        if (vint(END) < vint(START)) {
310 +                fprintf(stderr, "%s: ending frame less than starting frame\n",
311 +                                progname);
312 +                quit(1);
313 +        }
314          if (!vdef(BASENAME)) {
315                  sprintf(buf, "%s/frame%%03d", vval(DIRECTORY));
316                  vval(BASENAME) = savqstr(buf);
# Line 320 | Line 350 | setdefaults()                  /* set default values */
350   }
351  
352  
353 + sethosts()                      /* set up process servers */
354 + {
355 +        extern char     *iskip();
356 +        char    buf[256], *dir, *uname;
357 +        int     np;
358 +        register char   *cp;
359 +        int     i;
360 +
361 +        npslots = 0;
362 +        if (noaction)
363 +                return;
364 +        for (i = 0; i < vdef(HOST); i++) {      /* add each host */
365 +                dir = uname = NULL;
366 +                np = 1;
367 +                strcpy(cp=buf, nvalue(HOST, i));        /* copy to buffer */
368 +                cp = sskip(cp);                         /* skip host name */
369 +                while (isspace(*cp))
370 +                        *cp++ = '\0';
371 +                if (*cp) {                              /* has # processes? */
372 +                        np = atoi(cp);
373 +                        if ((cp = iskip(cp)) == NULL || (*cp && !isspace(*cp)))
374 +                                badvalue(HOST);
375 +                        while (isspace(*cp))
376 +                                cp++;
377 +                        if (*cp) {                      /* has directory? */
378 +                                dir = cp;
379 +                                cp = sskip(cp);                 /* skip dir. */
380 +                                while (isspace(*cp))
381 +                                        *cp++ = '\0';
382 +                                if (*cp) {                      /* has user? */
383 +                                        uname = cp;
384 +                                        if (*sskip(cp))
385 +                                                badvalue(HOST);
386 +                                }
387 +                        }
388 +                }
389 +                if (addpserver(buf, dir, uname, np) == NULL) {
390 +                        if (!nowarn)
391 +                                fprintf(stderr,
392 +                                        "%s: cannot execute on host \"%s\"\n",
393 +                                                progname, buf);
394 +                } else
395 +                        npslots += np;
396 +        }
397 +        if (npslots == 0) {
398 +                fprintf(stderr, "%s: no working process servers\n", progname);
399 +                quit(1);
400 +        }
401 +        pslot = (struct pslot *)calloc(npslots, sizeof(struct pslot));
402 +        if (pslot == NULL) {
403 +                perror("malloc");
404 +                quit(1);
405 +        }
406 + }
407 +
408 +
409   getradfile(rfname)              /* run rad and get needed variables */
410   char    *rfname;
411   {
# Line 406 | Line 492 | animate()                      /* run animation */
492                  astat.rnext = astat.fnext = astat.tnext = vint(START);
493          putastat();
494                                          /* render in batches */
495 <        while (astat.rnext <= vint(END)) {
495 >        while (astat.tnext <= vint(END)) {
496                  renderframes(frames_batch);
497                  filterframes();
498                  transferframes();
# Line 466 | Line 552 | int    nframes;
552                  }
553          }
554          if (vdef(ANIMATE))              /* wait for renderings to finish */
555 <                animwait(0);
555 >                bwait(0);
556          else {                          /* else if walk-through */
557                  fclose(fp);             /* close view file */
558                  walkwait(astat.rnext, lastframe, vfname);       /* walk it */
559                  unlink(vfname);         /* remove view file */
560          }
475 –        if (vdef(ARCHIVE))              /* archive results */
476 –                archive(astat.rnext, lastframe);
561          astat.rnext = i;                /* update status */
562          putastat();
563   }
# Line 494 | Line 578 | filterframes()                         /* catch up with filtering */
578                                          progname, i);
579                          quit(1);
580                  }
581 <                dofilt(i, vp, getexp(i));               /* filter frame */
581 >                dofilt(i, vp, getexp(i), 0);            /* filter frame */
582          }
583 <        filtwait(0);                    /* wait for filter processes */
583 >        bwait(0);                       /* wait for filter processes */
584 >        archive(astat.fnext, i-1);      /* archive originals */
585          astat.fnext = i;                /* update status */
586          putastat();
587   }
# Line 539 | Line 624 | animrend(frame, vp)                    /* start animation frame */
624   int     frame;
625   VIEW    *vp;
626   {
627 +        extern int      recover();
628          char    combuf[2048];
629          char    fname[128];
630  
# Line 546 | Line 632 | VIEW   *vp;
632          strcat(fname, ".unf");
633          if (access(fname, F_OK) == 0)
634                  return;
635 <        sprintf(combuf, "%s %d | rpict%s%s %s > %s", vval(ANIMATE), frame,
635 >        sprintf(combuf, "%s %d | rpict%s%s -w0 %s > %s", vval(ANIMATE), frame,
636                          rendopt, viewopt(vp), rresopt, fname);
637 <        if (runcom(combuf)) {
552 <                fprintf(stderr, "%s: error rendering frame %d\n",
553 <                                progname, frame);
554 <                quit(1);
555 <        }
637 >        bruncom(combuf, frame, recover);        /* run in background */
638   }
639  
640  
559 – animwait(nwait)                         /* wait for renderings to finish */
560 – int     nwait;
561 – {
562 –        /* currently does nothing since parallel rendering not working */
563 – }
564 –
565 –
641   walkwait(first, last, vfn)              /* walk-through frames */
642   int     first, last;
643   char    *vfn;
644   {
645          char    combuf[2048];
646 +        char    *inspoint;
647          register int    i;
648  
649          if (!noaction && vint(INTERP))          /* create dummy frames */
# Line 578 | Line 654 | char   *vfn;
654                                  close(open(combuf, O_RDONLY|O_CREAT, 0666));
655                          }
656                                          /* create command */
657 <        sprintf(combuf, "rpict%s ", rendopt);
657 >        sprintf(combuf, "rpict%s -w0", rendopt);
658          if (vint(INTERP) || atoi(vval(MBLUR)))
659 <                sprintf(combuf+strlen(combuf), "-z %s.zbf ", vval(BASENAME));
660 <        sprintf(combuf+strlen(combuf), "-o %s.unf %s -S %d %s < %s",
661 <                        vval(BASENAME), rresopt, first, vval(OCTREE), vfn);
662 <        if (runcom(combuf)) {
663 <                fprintf(stderr,
664 <                "%s: error rendering walk-through frames %d through %d\n",
659 >                sprintf(combuf+strlen(combuf), " -z %s.zbf", vval(BASENAME));
660 >        sprintf(combuf+strlen(combuf), " -o %s.unf %s -S %d",
661 >                        vval(BASENAME), rresopt, first);
662 >        inspoint = combuf + strlen(combuf);
663 >        sprintf(inspoint, " %s < %s", vval(OCTREE), vfn);
664 >                                        /* run in parallel */
665 >        if (pruncom(combuf, inspoint, (last-first+1)/(vint(INTERP)+1))) {
666 >                fprintf(stderr, "%s: error rendering frames %d through %d\n",
667                                  progname, first, last);
668                  quit(1);
669          }
# Line 599 | Line 677 | char   *vfn;
677   }
678  
679  
680 + int
681   recover(frame)                          /* recover the specified frame */
682   int     frame;
683   {
684 +        static int      *rfrm;          /* list of recovered frames */
685 +        static int      nrfrms = 0;
686          char    combuf[2048];
687          char    fname[128];
688          register char   *cp;
689 <
689 >        register int    i;
690 >                                        /* check to see if recovered already */
691 >        for (i = nrfrms; i--; )
692 >                if (rfrm[i] == frame)
693 >                        return(0);
694 >                                        /* build command */
695          sprintf(fname, vval(BASENAME), frame);
696          if (vdef(ANIMATE))
697 <                sprintf(combuf, "%s %d | rpict%s",
697 >                sprintf(combuf, "%s %d | rpict%s -w0",
698                                  vval(ANIMATE), frame, rendopt);
699          else
700 <                sprintf(combuf, "rpict%s", rendopt);
700 >                sprintf(combuf, "rpict%s -w0", rendopt);
701          cp = combuf + strlen(combuf);
702          if (vint(INTERP) || atoi(vval(MBLUR))) {
703                  sprintf(cp, " -z %s.zbf", fname);
# Line 623 | Line 709 | int    frame;
709                  *cp++ = ' ';
710                  strcpy(cp, vval(OCTREE));
711          }
712 <        if (runcom(combuf)) {
713 <                fprintf(stderr, "%s: error recovering frame %d\n",
714 <                                progname, frame);
712 >        if (runcom(combuf))             /* run command */
713 >                return(1);
714 >                                        /* add frame to recovered list */
715 >        if (nrfrms)
716 >                rfrm = (int *)realloc((char *)rfrm, (nrfrms+1)*sizeof(int));
717 >        else
718 >                rfrm = (int *)malloc(sizeof(int));
719 >        if (rfrm == NULL) {
720 >                perror("malloc");
721                  quit(1);
722          }
723 +        rfrm[nrfrms++] = frame;
724 +        return(0);
725   }
726  
727  
728 < archive(first, last)                    /* archive finished renderings */
728 > int
729 > frecover(frame)                         /* recover filtered frame */
730 > int     frame;
731 > {
732 >        VIEW    *vp;
733 >        char    *ex;
734 >
735 >        vp = getview(frame);
736 >        ex = getexp(frame);
737 >        if (dofilt(frame, vp, ex, 2) && dofilt(frame, vp, ex, 1))
738 >                return(1);
739 >        return(0);
740 > }
741 >
742 >
743 > archive(first, last)                    /* archive and remove renderings */
744   int     first, last;
745   {
746 + #define RMCOML  (sizeof(rmcom)-1)
747 +        static char     rmcom[] = "rm -f";
748 +        int     offset = RMCOML;
749          char    combuf[10240];
638 –        int     offset;
750          struct stat     stb;
751          register char   *cp;
752          register int    i;
753  
754 <        strcpy(cp=combuf, vval(ARCHIVE));
755 <        while (*cp) cp++;
756 <        offset = cp - combuf;
754 >        if (noaction)
755 >                return;
756 >        if (vdef(ARCHIVE) && strlen(vval(ARCHIVE)) > offset)
757 >                offset = strlen(vval(ARCHIVE));
758 >        cp = combuf + offset;
759          *cp++ = ' ';                            /* make argument list */
760          for (i = first; i <= last; i++) {
761                  sprintf(cp, vval(BASENAME), i);
# Line 661 | Line 774 | int    first, last;
774          *--cp = '\0';
775          if (cp <= combuf + offset)              /* no files? */
776                  return;
777 <        if (runcom(combuf)) {                   /* run archive command */
778 <                fprintf(stderr,
777 >        if (vdef(ARCHIVE)) {                    /* run archive command */
778 >                i = strlen(vval(ARCHIVE));
779 >                strncpy(combuf+offset-i, vval(ARCHIVE), i);
780 >                if (runcom(combuf+offset-i)) {
781 >                        fprintf(stderr,
782                  "%s: error running archive command on frames %d through %d\n",
783 <                                progname, first, last);
784 <                quit(1);
783 >                                        progname, first, last);
784 >                        quit(1);
785 >                }
786          }
787 +                                                /* run remove command */
788 +        strncpy(combuf+offset-RMCOML, rmcom, RMCOML);
789 +        runcom(combuf+offset-RMCOML);
790 + #undef RMCOML
791   }
792  
793  
794 < dofilt(frame, vp, ep)                           /* filter frame */
794 > int
795 > dofilt(frame, vp, ep, rvr)                      /* filter frame */
796   int     frame;
797   VIEW    *vp;
798   char    *ep;
799 + int     rvr;
800   {
801 +        extern int      frecover();
802 +        static int      iter = 0;
803          char    fnbefore[128], fnafter[128];
804 <        char    combuf[1024], fname[128];
804 >        char    combuf[1024], fname0[128], fname1[128];
805          int     usepinterp, usepfilt;
806 <        int     frbefore, frafter, triesleft;
806 >        int     frseq[2];
807                                                  /* check what is needed */
808          usepinterp = atoi(vval(MBLUR));
809          usepfilt = pfiltalways | ep==NULL;
810                                                  /* compute rendered views */
811 <        frbefore = frame - ((frame-1) % (vint(INTERP)+1));
812 <        frafter = frbefore + vint(INTERP) + 1;
813 <        if (frafter > vint(END))
814 <                frafter = vint(END);
815 <        if (frafter == frame) {                 /* pfilt only */
816 <                frbefore = frafter;
811 >        frseq[0] = frame - ((frame-1) % (vint(INTERP)+1));
812 >        frseq[1] = frseq[0] + vint(INTERP) + 1;
813 >        if (frseq[1] > vint(END))
814 >                frseq[1] = vint(END);
815 >        if (frseq[1] == frame) {                        /* pfilt only */
816 >                frseq[0] = frseq[1];
817                  usepinterp = 0;                 /* update what's needed */
818                  usepfilt |= vflt(OVERSAMP)>1.01 || strcmp(ep,"1");
819 <                triesleft = 2;
695 <        } else if (frbefore == frame) {         /* no interpolation */
696 <                                                /* remove unneeded files */
697 <                if (frbefore-vint(INTERP)-1 >= 1) {
698 <                        sprintf(fname, vval(BASENAME), frbefore-vint(INTERP)-1);
699 <                        sprintf(combuf, "rm -f %s.unf %s.zbf", fname, fname);
700 <                        runcom(combuf);
701 <                }
819 >        } else if (frseq[0] == frame) {         /* no interpolation */
820                                                  /* update what's needed */
821 <                if (usepinterp)
704 <                        triesleft = 3;
705 <                else {
821 >                if (!usepinterp)
822                          usepfilt |= vflt(OVERSAMP)>1.01 || strcmp(ep,"1");
823 <                        triesleft = 2;
708 <                }
709 <        } else {                                /* interpolation needed */
823 >        } else                                  /* interpolation needed */
824                  usepinterp++;
825 <                triesleft = 3;
826 <        }
827 <        if (frafter >= astat.rnext) {           /* next batch unavailable */
828 <                frafter = frbefore;
829 <                if (triesleft > 2)
830 <                        triesleft = 2;
831 <        }
718 <        sprintf(fnbefore, vval(BASENAME), frbefore);
719 <        sprintf(fnafter, vval(BASENAME), frafter);
720 < tryit:                                          /* generate command */
825 >        if (frseq[1] >= astat.rnext)            /* next batch unavailable */
826 >                frseq[1] = frseq[0];
827 >        sprintf(fnbefore, vval(BASENAME), frseq[0]);
828 >        sprintf(fnafter, vval(BASENAME), frseq[1]);
829 >        if (rvr == 1 && recover(frseq[0]))      /* recover before frame? */
830 >                return(1);
831 >                                                /* generate command */
832          if (usepinterp) {                       /* using pinterp */
833 +                if (rvr == 2 && recover(frseq[1]))      /* recover after? */
834 +                        return(1);
835                  if (atoi(vval(MBLUR))) {
836                          FILE    *fp;            /* motion blurring */
837 <                        sprintf(fname, "%s/vw0", vval(DIRECTORY));
838 <                        if ((fp = fopen(fname, "w")) == NULL) {
839 <                                perror(fname); quit(1);
837 >                        sprintf(fname0, "%s/vw0%c", vval(DIRECTORY),
838 >                                        'a'+(iter%26));
839 >                        if ((fp = fopen(fname0, "w")) == NULL) {
840 >                                perror(fname0); quit(1);
841                          }
842                          fputs(VIEWSTR, fp);
843                          fprintview(vp, fp);
# Line 734 | Line 848 | tryit:                                         /* generate command */
848                                                  progname, frame+1);
849                                  quit(1);
850                          }
851 <                        sprintf(fname, "%s/vw1", vval(DIRECTORY));
852 <                        if ((fp = fopen(fname, "w")) == NULL) {
853 <                                perror(fname); quit(1);
851 >                        sprintf(fname1, "%s/vw1%c", vval(DIRECTORY),
852 >                                        'a'+(iter%26));
853 >                        if ((fp = fopen(fname1, "w")) == NULL) {
854 >                                perror(fname1); quit(1);
855                          }
856                          fputs(VIEWSTR, fp);
857                          fprintview(vp, fp);
858                          putc('\n', fp); fclose(fp);
859                          sprintf(combuf,
860 <        "(pmblur %s %d %s/vw0 %s/vw1; rm -f %s/vw0 %s/vw1) | pinterp -B",
861 <                                *sskip(vval(MBLUR)) ? sskip(vval(MBLUR)) : "1",
862 <                                        atoi(vval(MBLUR)), vval(DIRECTORY),
863 <                                        vval(DIRECTORY), vval(DIRECTORY),
864 <                                        vval(DIRECTORY), vval(DIRECTORY));
860 >                        "(pmblur %s %d %s %s; rm -f %s %s) | pinterp -B",
861 >                        *sskip(vval(MBLUR)) ? sskip2(vval(MBLUR),1) : "1",
862 >                                        atoi(vval(MBLUR)),
863 >                                        fname0, fname1, fname0, fname1);
864 >                        iter++;
865                  } else                          /* no blurring */
866                          strcpy(combuf, "pinterp");
867                  strcat(combuf, viewopt(vp));
868                  if (vbool(RTRACE))
869 <                        sprintf(combuf+strlen(combuf), " -ff -fr '%s %s'",
869 >                        sprintf(combuf+strlen(combuf), " -ff -fr '%s -w0 %s'",
870                                          rendopt, vval(OCTREE));
871                  if (vdef(PINTERP))
872                          sprintf(combuf+strlen(combuf), " %s", vval(PINTERP));
# Line 762 | Line 877 | tryit:                                         /* generate command */
877                                          fresopt, ep);
878                  sprintf(combuf+strlen(combuf), " %s.unf %s.zbf",
879                                  fnbefore, fnbefore);
880 <                if (frafter != frbefore)
880 >                if (frseq[1] != frseq[0])
881                           sprintf(combuf+strlen(combuf), " %s.unf %s.zbf",
882                                          fnafter, fnafter);
883                  if (usepfilt) {                 /* also pfilt */
# Line 778 | Line 893 | tryit:                                         /* generate command */
893                                  sprintf(combuf+strlen(combuf), " %s", fresopt);
894                  }
895          } else if (usepfilt) {                  /* pfilt only */
896 +                if (rvr == 2)
897 +                        return(1);
898                  if (vdef(PFILT))
899                          sprintf(combuf, "pfilt %s", vval(PFILT));
900                  else
# Line 789 | Line 906 | tryit:                                         /* generate command */
906                          sprintf(combuf+strlen(combuf), " %s %s.unf",
907                                          fresopt, fnbefore);
908          } else {                                /* else just check it */
909 +                if (rvr == 2)
910 +                        return(1);
911                  sprintf(combuf, "ra_rgbe -r %s.unf", fnbefore);
912          }
913                                                  /* output file name */
914 <        sprintf(fname, vval(BASENAME), frame);
915 <        sprintf(combuf+strlen(combuf), " > %s.pic", fname);
916 <        if (runcom(combuf))                     /* run filter command */
917 <                switch (--triesleft) {
918 <                case 2:                         /* try to recover frafter */
919 <                        recover(frafter);
801 <                        goto tryit;
802 <                case 1:                         /* try to recover frbefore */
803 <                        recover(frbefore);
804 <                        goto tryit;
805 <                default:                        /* we've really failed */
806 <                        fprintf(stderr,
807 <                        "%s: unrecoverable filtering error on frame %d\n",
808 <                                        progname, frame);
809 <                        quit(1);
810 <                }
914 >        sprintf(fname0, vval(BASENAME), frame);
915 >        sprintf(combuf+strlen(combuf), " > %s.pic", fname0);
916 >        if (rvr)                                /* in recovery */
917 >                return(runcom(combuf));
918 >        bruncom(combuf, frame, frecover);       /* else run in background */
919 >        return(0);
920   }
921  
922  
814 – filtwait(nwait)                 /* wait for filtering processes to finish */
815 – int     nwait;
816 – {
817 –        /* currently does nothing since parallel filtering not working */
818 – }
819 –
820 –
923   VIEW *
924   getview(n)                      /* get view number n */
925   int     n;
# Line 937 | Line 1039 | int    n;
1039   }
1040  
1041  
1042 < runcom(cs)                      /* run command */
1042 > struct pslot *
1043 > findpslot(pid)                  /* find or allocate a process slot */
1044 > int     pid;
1045 > {
1046 >        register struct pslot   *psempty = NULL;
1047 >        register int    i;
1048 >
1049 >        for (i = 0; i < npslots; i++) {         /* look for match */
1050 >                if (pslot[i].pid == pid)
1051 >                        return(pslot+i);
1052 >                if (psempty == NULL && pslot[i].pid == 0)
1053 >                        psempty = pslot+i;
1054 >        }
1055 >        return(psempty);                /* return emtpy slot (error if NULL) */
1056 > }
1057 >
1058 >
1059 > int
1060 > donecom(ps, pn, status)         /* clean up after finished process */
1061 > PSERVER *ps;
1062 > int     pn;
1063 > int     status;
1064 > {
1065 >        register PROC   *pp;
1066 >
1067 >        pp = ps->proc + pn;
1068 >        if (pp->elen) {                 /* pass errors */
1069 >                if (ps->hostname[0])
1070 >                        fprintf(stderr, "%s: ", ps->hostname);
1071 >                fprintf(stderr, "Error output from: %s\n", pp->com);
1072 >                fputs(pp->errs, stderr);
1073 >                fflush(stderr);
1074 >                if (ps->hostname[0])
1075 >                        status = 1;     /* because rsh doesn't return status */
1076 >        }
1077 >        freestr(pp->com);               /* free command string */
1078 >        lastpid = pp->pid;              /* record PID for bwait() */
1079 >        lastpserver = ps;               /* record server for serverdown() */
1080 >        return(status);
1081 > }
1082 >
1083 >
1084 > int
1085 > serverdown()                    /* check status of last process server */
1086 > {
1087 >        if (pserverOK(lastpserver))     /* server still up? */
1088 >                return(0);
1089 >        delpserver(lastpserver);        /* else delete it */
1090 >        if (pslist == NULL) {
1091 >                fprintf(stderr, "%s: all process servers are down\n",
1092 >                                progname);
1093 >                quit(1);
1094 >        }
1095 >        return(1);
1096 > }
1097 >
1098 >
1099 > int
1100 > bruncom(com, fout, rf)          /* run a command in the background */
1101 > char    *com;
1102 > int     fout;
1103 > int     (*rf)();
1104 > {
1105 >        int     pid;
1106 >        register struct pslot   *psl;
1107 >
1108 >        if (noaction) {
1109 >                if (!silent)
1110 >                        printf("\t%s\n", com);  /* echo command */
1111 >                return(0);
1112 >        }
1113 >                                        /* else start it when we can */
1114 >        while ((pid = startjob(NULL, savestr(com), donecom)) == -1)
1115 >                bwait(1);
1116 >        if (!silent) {                          /* echo command */
1117 >                PSERVER *ps;
1118 >                int     psn = pid;
1119 >                ps = findjob(&psn);
1120 >                printf("\t%s\n", com);
1121 >                printf("\tProcess started on %s\n", phostname(ps));
1122 >                fflush(stdout);
1123 >        }
1124 >        psl = findpslot(pid);           /* record info. in appropriate slot */
1125 >        psl->pid = pid;
1126 >        psl->fout = fout;
1127 >        psl->rcvf = rf;
1128 >        return(pid);
1129 > }
1130 >
1131 >
1132 > bwait(ncoms)                            /* wait for batch job(s) to finish */
1133 > int     ncoms;
1134 > {
1135 >        int     status;
1136 >        register struct pslot   *psl;
1137 >
1138 >        if (noaction)
1139 >                return;
1140 >        while ((status = wait4job(NULL, -1)) != -1) {
1141 >                psl = findpslot(lastpid);
1142 >                if (status) {           /* attempt recovery */
1143 >                        serverdown();   /* check server */
1144 >                        if (psl->rcvf == NULL || (*psl->rcvf)(psl->fout)) {
1145 >                                fprintf(stderr,
1146 >                                        "%s: error rendering frame %d\n",
1147 >                                                progname, psl->fout);
1148 >                                quit(1);
1149 >                        }
1150 >                }
1151 >                psl->pid = 0;           /* free process slot */
1152 >                if (!--ncoms)
1153 >                        return;         /* done enough */
1154 >        }
1155 > }
1156 >
1157 >
1158 > int
1159 > pruncom(com, ppins, maxcopies)  /* run a command in parallel over network */
1160 > char    *com, *ppins;
1161 > int     maxcopies;
1162 > {
1163 >        int     retstatus = 0;
1164 >        int     hostcopies;
1165 >        char    com1buf[10240], *com1, *endcom1;
1166 >        int     status;
1167 >        register PSERVER        *ps;
1168 >
1169 >        if (!silent)
1170 >                printf("\t%s\n", com);  /* echo command */
1171 >        if (noaction)
1172 >                return(0);
1173 >        fflush(stdout);
1174 >                                        /* start jobs on each server */
1175 >        for (ps = pslist; ps != NULL; ps = ps->next) {
1176 >                hostcopies = 0;
1177 >                if (maxcopies > 1 && ps->nprocs > 1 && ppins != NULL) {
1178 >                        strcpy(com1=com1buf, com);      /* build -PP command */
1179 >                        sprintf(com1+(ppins-com), " -PP %s/%s.persist",
1180 >                                        vval(DIRECTORY), phostname(ps));
1181 >                        strcat(com1, ppins);
1182 >                        endcom1 = com1 + strlen(com1);
1183 >                        sprintf(endcom1, "; kill `sed -n '1s/^[^ ]* //p' %s/%s.persist`",
1184 >                                        vval(DIRECTORY), phostname(ps));
1185 >                } else {
1186 >                        com1 = com;
1187 >                        endcom1 = NULL;
1188 >                }
1189 >                while (maxcopies > 0 &&
1190 >                                startjob(ps, savestr(com1), donecom) != -1) {
1191 >                        sleep(10);
1192 >                        hostcopies++;
1193 >                        maxcopies--;
1194 >                        if (endcom1 != NULL)
1195 >                                *endcom1 = '\0';
1196 >                }
1197 >                if (!silent && hostcopies) {
1198 >                        if (hostcopies > 1)
1199 >                                printf("\t%d duplicate processes", hostcopies);
1200 >                        else
1201 >                                printf("\tProcess");
1202 >                        printf(" started on %s\n", phostname(ps));
1203 >                        fflush(stdout);
1204 >                }
1205 >        }
1206 >                                        /* wait for jobs to finish */
1207 >        while ((status = wait4job(NULL, -1)) != -1)
1208 >                if (status)
1209 >                        retstatus += !serverdown();     /* check server */
1210 >        return(retstatus);
1211 > }
1212 >
1213 >
1214 > runcom(cs)                      /* run a command locally and wait for it */
1215   char    *cs;
1216   {
1217          if (!silent)            /* echo it */

Diff Legend

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