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.5 by greg, Tue Jan 23 16:14:28 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          char    fnbefore[128], fnafter[128];
803          char    combuf[1024], fname[128];
804          int     usepinterp, usepfilt;
805 <        int     frbefore, frafter, triesleft;
805 >        int     frseq[2];
806                                                  /* check what is needed */
807          usepinterp = atoi(vval(MBLUR));
808          usepfilt = pfiltalways | ep==NULL;
809                                                  /* compute rendered views */
810 <        frbefore = frame - ((frame-1) % (vint(INTERP)+1));
811 <        frafter = frbefore + vint(INTERP) + 1;
812 <        if (frafter > vint(END))
813 <                frafter = vint(END);
814 <        if (frafter == frame) {                 /* pfilt only */
815 <                frbefore = frafter;
810 >        frseq[0] = frame - ((frame-1) % (vint(INTERP)+1));
811 >        frseq[1] = frseq[0] + vint(INTERP) + 1;
812 >        if (frseq[1] > vint(END))
813 >                frseq[1] = vint(END);
814 >        if (frseq[1] == frame) {                        /* pfilt only */
815 >                frseq[0] = frseq[1];
816                  usepinterp = 0;                 /* update what's needed */
817                  usepfilt |= vflt(OVERSAMP)>1.01 || strcmp(ep,"1");
818 <                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 <                }
818 >        } else if (frseq[0] == frame) {         /* no interpolation */
819                                                  /* update what's needed */
820 <                if (usepinterp)
704 <                        triesleft = 3;
705 <                else {
820 >                if (!usepinterp)
821                          usepfilt |= vflt(OVERSAMP)>1.01 || strcmp(ep,"1");
822 <                        triesleft = 2;
708 <                }
709 <        } else {                                /* interpolation needed */
822 >        } else                                  /* interpolation needed */
823                  usepinterp++;
824 <                triesleft = 3;
825 <        }
826 <        if (frafter >= astat.rnext) {           /* next batch unavailable */
827 <                frafter = frbefore;
828 <                if (triesleft > 2)
829 <                        triesleft = 2;
830 <        }
718 <        sprintf(fnbefore, vval(BASENAME), frbefore);
719 <        sprintf(fnafter, vval(BASENAME), frafter);
720 < tryit:                                          /* generate command */
824 >        if (frseq[1] >= astat.rnext)            /* next batch unavailable */
825 >                frseq[1] = frseq[0];
826 >        sprintf(fnbefore, vval(BASENAME), frseq[0]);
827 >        sprintf(fnafter, vval(BASENAME), frseq[1]);
828 >        if (rvr == 1 && recover(frseq[0]))      /* recover before frame? */
829 >                return(1);
830 >                                                /* generate command */
831          if (usepinterp) {                       /* using pinterp */
832 +                if (rvr == 2 && recover(frseq[1]))      /* recover after? */
833 +                        return(1);
834                  if (atoi(vval(MBLUR))) {
835                          FILE    *fp;            /* motion blurring */
836                          sprintf(fname, "%s/vw0", vval(DIRECTORY));
837 +                        if (access(fname, F_OK) == 0)
838 +                                sleep(10);
839                          if ((fp = fopen(fname, "w")) == NULL) {
840                                  perror(fname); quit(1);
841                          }
# Line 743 | Line 857 | tryit:                                         /* generate command */
857                          putc('\n', fp); fclose(fp);
858                          sprintf(combuf,
859          "(pmblur %s %d %s/vw0 %s/vw1; rm -f %s/vw0 %s/vw1) | pinterp -B",
860 <                                *sskip(vval(MBLUR)) ? sskip(vval(MBLUR)) : "1",
860 >                        *sskip(vval(MBLUR)) ? sskip2(vval(MBLUR),1) : "1",
861                                          atoi(vval(MBLUR)), vval(DIRECTORY),
862                                          vval(DIRECTORY), vval(DIRECTORY),
863                                          vval(DIRECTORY), vval(DIRECTORY));
# Line 751 | Line 865 | tryit:                                         /* generate command */
865                          strcpy(combuf, "pinterp");
866                  strcat(combuf, viewopt(vp));
867                  if (vbool(RTRACE))
868 <                        sprintf(combuf+strlen(combuf), " -ff -fr '%s %s'",
868 >                        sprintf(combuf+strlen(combuf), " -ff -fr '%s -w0 %s'",
869                                          rendopt, vval(OCTREE));
870                  if (vdef(PINTERP))
871                          sprintf(combuf+strlen(combuf), " %s", vval(PINTERP));
# Line 762 | Line 876 | tryit:                                         /* generate command */
876                                          fresopt, ep);
877                  sprintf(combuf+strlen(combuf), " %s.unf %s.zbf",
878                                  fnbefore, fnbefore);
879 <                if (frafter != frbefore)
879 >                if (frseq[1] != frseq[0])
880                           sprintf(combuf+strlen(combuf), " %s.unf %s.zbf",
881                                          fnafter, fnafter);
882                  if (usepfilt) {                 /* also pfilt */
# Line 778 | Line 892 | tryit:                                         /* generate command */
892                                  sprintf(combuf+strlen(combuf), " %s", fresopt);
893                  }
894          } else if (usepfilt) {                  /* pfilt only */
895 +                if (rvr == 2)
896 +                        return(1);
897                  if (vdef(PFILT))
898                          sprintf(combuf, "pfilt %s", vval(PFILT));
899                  else
# Line 789 | Line 905 | tryit:                                         /* generate command */
905                          sprintf(combuf+strlen(combuf), " %s %s.unf",
906                                          fresopt, fnbefore);
907          } else {                                /* else just check it */
908 +                if (rvr == 2)
909 +                        return(1);
910                  sprintf(combuf, "ra_rgbe -r %s.unf", fnbefore);
911          }
912                                                  /* output file name */
913          sprintf(fname, vval(BASENAME), frame);
914          sprintf(combuf+strlen(combuf), " > %s.pic", fname);
915 <        if (runcom(combuf))                     /* run filter command */
916 <                switch (--triesleft) {
917 <                case 2:                         /* try to recover frafter */
918 <                        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 <                }
915 >        if (rvr)                                /* in recovery */
916 >                return(runcom(combuf));
917 >        bruncom(combuf, frame, frecover);       /* else run in background */
918 >        return(0);
919   }
920  
921  
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 –
922   VIEW *
923   getview(n)                      /* get view number n */
924   int     n;
# Line 937 | Line 1038 | int    n;
1038   }
1039  
1040  
1041 < runcom(cs)                      /* run command */
1041 > struct pslot *
1042 > findpslot(pid)                  /* find or allocate a process slot */
1043 > int     pid;
1044 > {
1045 >        register struct pslot   *psempty = NULL;
1046 >        register int    i;
1047 >
1048 >        for (i = 0; i < npslots; i++) {         /* look for match */
1049 >                if (pslot[i].pid == pid)
1050 >                        return(pslot+i);
1051 >                if (psempty == NULL && pslot[i].pid == 0)
1052 >                        psempty = pslot+i;
1053 >        }
1054 >        return(psempty);                /* return emtpy slot (error if NULL) */
1055 > }
1056 >
1057 >
1058 > int
1059 > donecom(ps, pn, status)         /* clean up after finished process */
1060 > PSERVER *ps;
1061 > int     pn;
1062 > int     status;
1063 > {
1064 >        register PROC   *pp;
1065 >
1066 >        pp = ps->proc + pn;
1067 >        if (pp->elen) {                 /* pass errors */
1068 >                if (ps->hostname[0])
1069 >                        fprintf(stderr, "%s: ", ps->hostname);
1070 >                fprintf(stderr, "Error output from: %s\n", pp->com);
1071 >                fputs(pp->errs, stderr);
1072 >                fflush(stderr);
1073 >                if (ps->hostname[0])
1074 >                        status = 1;     /* because rsh doesn't return status */
1075 >        }
1076 >        freestr(pp->com);               /* free command string */
1077 >        lastpid = pp->pid;              /* record PID for bwait() */
1078 >        lastpserver = ps;               /* record server for serverdown() */
1079 >        return(status);
1080 > }
1081 >
1082 >
1083 > int
1084 > serverdown()                    /* check status of last process server */
1085 > {
1086 >        if (pserverOK(lastpserver))     /* server still up? */
1087 >                return(0);
1088 >        delpserver(lastpserver);        /* else delete it */
1089 >        if (pslist == NULL) {
1090 >                fprintf(stderr, "%s: all process servers are down\n",
1091 >                                progname);
1092 >                quit(1);
1093 >        }
1094 >        return(1);
1095 > }
1096 >
1097 >
1098 > int
1099 > bruncom(com, fout, rf)          /* run a command in the background */
1100 > char    *com;
1101 > int     fout;
1102 > int     (*rf)();
1103 > {
1104 >        int     pid;
1105 >        register struct pslot   *psl;
1106 >
1107 >        if (noaction) {
1108 >                if (!silent)
1109 >                        printf("\t%s\n", com);  /* echo command */
1110 >                return(0);
1111 >        }
1112 >                                        /* else start it when we can */
1113 >        while ((pid = startjob(NULL, savestr(com), donecom)) == -1)
1114 >                bwait(1);
1115 >        if (!silent) {                          /* echo command */
1116 >                PSERVER *ps;
1117 >                int     psn = pid;
1118 >                ps = findjob(&psn);
1119 >                printf("\t%s\n", com);
1120 >                printf("\tProcess started on %s\n", phostname(ps));
1121 >                fflush(stdout);
1122 >        }
1123 >        psl = findpslot(pid);           /* record info. in appropriate slot */
1124 >        psl->pid = pid;
1125 >        psl->fout = fout;
1126 >        psl->rcvf = rf;
1127 >        return(pid);
1128 > }
1129 >
1130 >
1131 > bwait(ncoms)                            /* wait for batch job(s) to finish */
1132 > int     ncoms;
1133 > {
1134 >        int     status;
1135 >        register struct pslot   *psl;
1136 >
1137 >        if (noaction)
1138 >                return;
1139 >        while ((status = wait4job(NULL, -1)) != -1) {
1140 >                psl = findpslot(lastpid);
1141 >                if (status) {           /* attempt recovery */
1142 >                        serverdown();   /* check server */
1143 >                        if (psl->rcvf == NULL || (*psl->rcvf)(psl->fout)) {
1144 >                                fprintf(stderr,
1145 >                                        "%s: error rendering frame %d\n",
1146 >                                                progname, psl->fout);
1147 >                                quit(1);
1148 >                        }
1149 >                }
1150 >                psl->pid = 0;           /* free process slot */
1151 >                if (!--ncoms)
1152 >                        return;         /* done enough */
1153 >        }
1154 > }
1155 >
1156 >
1157 > int
1158 > pruncom(com, ppins, maxcopies)  /* run a command in parallel over network */
1159 > char    *com, *ppins;
1160 > int     maxcopies;
1161 > {
1162 >        int     retstatus = 0;
1163 >        int     hostcopies;
1164 >        char    com1buf[10240], *com1, *endcom1;
1165 >        int     status;
1166 >        register PSERVER        *ps;
1167 >
1168 >        if (!silent)
1169 >                printf("\t%s &\n", com);        /* echo command */
1170 >        if (noaction)
1171 >                return(0);
1172 >        fflush(stdout);
1173 >                                        /* start jobs on each server */
1174 >        for (ps = pslist; ps != NULL; ps = ps->next) {
1175 >                hostcopies = 0;
1176 >                if (maxcopies > 1 && ps->nprocs > 1 && ppins != NULL) {
1177 >                        strcpy(com1=com1buf, com);      /* build -PP command */
1178 >                        sprintf(com1+(ppins-com), " -PP %s/%s.persist",
1179 >                                        vval(DIRECTORY), phostname(ps));
1180 >                        strcat(com1, ppins);
1181 >                        endcom1 = com1 + strlen(com1);
1182 >                        sprintf(endcom1, "; kill `sed -n '1s/^[^ ]* //p' %s/%s.persist`",
1183 >                                        vval(DIRECTORY), phostname(ps));
1184 >                } else {
1185 >                        com1 = com;
1186 >                        endcom1 = NULL;
1187 >                }
1188 >                while (maxcopies > 0 &&
1189 >                                startjob(ps, savestr(com1), donecom) != -1) {
1190 >                        sleep(10);
1191 >                        hostcopies++;
1192 >                        maxcopies--;
1193 >                        if (endcom1 != NULL)
1194 >                                *endcom1 = '\0';
1195 >                }
1196 >                if (!silent && hostcopies) {
1197 >                        if (hostcopies > 1)
1198 >                                printf("\t%d duplicate processes", hostcopies);
1199 >                        else
1200 >                                printf("\tProcess");
1201 >                        printf(" started on %s\n", phostname(ps));
1202 >                        fflush(stdout);
1203 >                }
1204 >        }
1205 >                                        /* wait for jobs to finish */
1206 >        while ((status = wait4job(NULL, -1)) != -1)
1207 >                if (status)
1208 >                        retstatus += !serverdown();     /* check server */
1209 >        return(retstatus);
1210 > }
1211 >
1212 >
1213 > runcom(cs)                      /* run a command locally and wait for it */
1214   char    *cs;
1215   {
1216          if (!silent)            /* echo it */

Diff Legend

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