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

Comparing ray/src/util/rcomb.c (file contents):
Revision 2.8 by greg, Thu May 16 18:59:19 2024 UTC vs.
Revision 2.10 by greg, Mon May 20 23:21:29 2024 UTC

# Line 5 | Line 5 | static const char RCSid[] = "$Id$";
5   * General component matrix combiner, operating on a row at a time.
6   */
7  
8 – #include <errno.h>
8   #include <math.h>
9   #include "platform.h"
10 + #include "rtprocess.h"
11   #include "rtio.h"
12   #include "rmatrix.h"
13   #include "calcomp.h"
14 – #include "paths.h"
14  
15   #ifndef M_PI
16   #define M_PI    3.14159265358979323846
# Line 54 | Line 53 | int            cur_row;                        /* current input/output row */
53   int             cur_col;                        /* current input/output column */
54   int             cur_chan;                       /* if we're looping channels */
55  
56 + SUBPROC         *cproc = NULL;                  /* child process array */
57 + int             nchildren = 0;                  /* # of child processes */
58 + int             inchild = -1;                   /* our child ID (-1: parent) */
59 +
60   static int      checksymbolic(ROPMAT *rop);
61  
62   static int
# Line 390 | Line 393 | apply_op(RMATRIX *dst, const RMATRIX *src, const RUNAR
393                          return(0);
394                  rmx_free(res);
395          } else if (dst != src)
396 <                memcpy(dst->mtx, src->mtx,
394 <                                sizeof(double)*dst->ncomp*dst->ncols*dst->nrows);
396 >                memcpy(dst->mtx, src->mtx, rmx_array_size(dst));
397          if (ro->nsf == dst->ncomp)
398                  rmx_scale(dst, ro->sca);
399          return(1);
# Line 539 | Line 541 | output_headinfo(FILE *fp)
541   }
542  
543   static int
544 < combine_input(ROPMAT *res, FILE *fout)
544 > spawned_children(int np)
545   {
546 <        int     set_r, set_c;
547 <        RMATRIX *tmp = NULL;
548 <        int     co_set;
549 <        int     i;
550 <                                        /* allocate input row buffers */
546 >        int     i, rv;
547 >
548 > #if defined(_WIN32) || defined(_WIN64)
549 >        if (np > 1) {
550 >                fputs("Warning: only one process under Windows\n", stderr);
551 >                np = 1;
552 >        } else
553 > #endif
554 >        if ((in_nrows > 0) & (np > in_nrows))
555 >                np = in_nrows;
556 >                                /* we'll be doing a row at a time */
557          for (i = 0; i < nmats; i++) {
558 <                mop[i].imx.nrows = 1;   /* we'll be doing a row at a time */
558 >                mop[i].imx.nrows = 1;
559                  if (!rmx_prepare(&mop[i].imx))
560                          goto memerror;
561                  if (mop[i].rmp != &mop[i].imx) {
# Line 556 | Line 564 | combine_input(ROPMAT *res, FILE *fout)
564                                  goto memerror;
565                  }
566          }
567 <                                        /* prep output row buffers */
568 <        if (mcat || res->preop.clen > 0) {
569 <                if (!split_input(res))  /* need separate buffer */
567 >                                /* prep output row buffer */
568 >        if (mcat || mop[nmats].preop.clen > 0) {
569 >                if (!split_input(&mop[nmats]))  /* need separate buffer */
570                          return(0);
571 <                if (res->preop.clen > 0)
572 <                        res->rmp->ncomp = res->preop.clen / res->imx.ncomp;
573 <                res->rmp->nrows = 1;
574 <                if (!mcat | !mcat_last && !rmx_prepare(res->rmp))
571 >                if (mop[nmats].preop.clen > 0)
572 >                        mop[nmats].rmp->ncomp = mop[nmats].preop.clen /
573 >                                                mop[nmats].imx.ncomp;
574 >                mop[nmats].rmp->nrows = 1;
575 >                if (!mcat | !mcat_last && !rmx_prepare(mop[nmats].rmp))
576                          goto memerror;
577          }
578 +        mop[nmats].imx.nrows = 1;
579 +        if (!rmx_prepare(&mop[nmats].imx))
580 +                goto memerror;
581 +        if (np <= 1) {          /* single process return point */
582 + #ifdef getc_unlocked
583 +                for (i = 0; i < nmats; i++)
584 +                        flockfile(mop[i].infp);
585 +                flockfile(stdout);
586 + #endif
587 +                return(0);
588 +        }
589 +        fflush(stdout);         /* flush header & spawn children */
590 +        cproc = (SUBPROC *)malloc(sizeof(SUBPROC)*np);
591 +        if (!cproc)
592 +                goto memerror;
593 +        nchildren = np;
594 +        for (i = 0; i < np; i++) {
595 +                cproc[i].flags = PF_FILT_OUT;
596 +                cproc[i].w = dup(1);
597 +                cproc[i].r = 0;
598 +                cproc[i].pid = -1;
599 +                rv = open_process(&cproc[i], NULL);
600 +                if (rv <= 0) break;
601 +        }
602 +        if (rv > 0)
603 +                return(1);      /* parent return value */
604 +        if (rv < 0) {
605 +                perror("fork");
606 +                exit(1);
607 +        }
608 +        inchild = i;            /* child index */
609 +        fpurge(stdin);          /* discard previous matrix input */
610 + #ifdef getc_unlocked
611 +        flockfile(stdin);
612 + #endif
613 +        for (i = 0; i < nmats; i++) {
614 +                if (mop[i].infp != stdin)
615 +                        fclose(mop[i].infp);
616 +                mop[i].infp = stdin;
617 +                mop[i].imx.dtype = DTdouble;
618 +        }
619 +        return(0);              /* child return */
620 + memerror:
621 +        fputs("Out of memory in spawned_children()\n", stderr);
622 +        exit(1);
623 + }
624 +
625 + static int
626 + parent_loop()
627 + {
628 +        FILE    **outfp = (FILE **)malloc(nchildren*sizeof(FILE *));
629 +        int     i;
630 +
631 +        if (!outfp) goto memerror;
632 +        for (i = 0; i < nchildren; i++) {
633 +                outfp[i] = fdopen(cproc[i].w, "w");
634 +                if (!outfp[i]) goto memerror;
635 + #ifdef getc_unlocked
636 +                flockfile(outfp[i]);
637 + #endif
638 +        }
639 + #ifdef getc_unlocked
640 +        for (i = 0; i < nmats; i++)
641 +                flockfile(mop[i].infp);
642 + #endif
643 +        for (cur_row = 0; (in_nrows <= 0) | (cur_row < in_nrows); cur_row++) {
644 +            FILE        *ofp = outfp[cur_row % nchildren];
645 +            for (i = 0; i < nmats; i++) {
646 +                if (!rmx_load_row(mop[i].imx.mtx, &mop[i].imx, mop[i].infp)) {
647 +                        if (cur_row > in_nrows) /* unknown #input rows? */
648 +                                break;
649 +                        fprintf(stderr, "%s: read error at row %d\n",
650 +                                        mop[i].inspec, cur_row);
651 +                        return(0);
652 +                }
653 +                if (!rmx_write_data(mop[i].imx.mtx, mop[i].imx.ncomp,
654 +                                mop[i].imx.ncols, DTdouble, ofp))
655 +                        return(0);
656 +            }
657 +            if (i < nmats)
658 +                break;
659 +            if (fflush(ofp) == EOF)
660 +                return(0);
661 +        }
662 +        for (i = 0; i < nchildren; i++)
663 +                fclose(outfp[i]);
664 +        free(outfp);
665 +        i = close_processes(cproc, nchildren);
666 +        free(cproc); cproc = NULL;
667 +        if (i < 0) {
668 +                fputs("Warning: missing child in parent_loop()\n", stderr);
669 +                return(1);
670 +        }
671 +        if (i > 0) {
672 +                fprintf(stderr, "Child exited with status %d\n", i);
673 +                return(0);
674 +        }
675 +        return(1);
676 + memerror:
677 +        fputs("Out of memory in parent_loop()\n", stderr);
678 +        exit(1);
679 + }
680 +
681 + static int
682 + combine_input()
683 + {
684 +        const int       row0 = (inchild >= 0)*inchild;
685 +        const int       rstep = nchildren + !nchildren;
686 +        ROPMAT          *res = &mop[nmats];
687 +        int             set_r, set_c;
688 +        RMATRIX         *tmp = NULL;
689 +        int             co_set;
690 +        int             i;
691 +
692          if (mcat && mcat_last &&
693                          !(tmp = rmx_alloc(1, res->imx.ncols, res->rmp->ncomp)))
694                  goto memerror;
572 –        res->imx.nrows = 1;
573 –        if (!rmx_prepare(&res->imx))
574 –                goto memerror;
695                                          /* figure out what the user set */
696          co_set = fundefined("co");
697          if (!co_set)
# Line 587 | Line 707 | combine_input(ROPMAT *res, FILE *fout)
707          } else                          /* save a little time */
708                  set_r = set_c = 0;
709                                          /* read/process row-by-row */
710 <        for (cur_row = 0; (in_nrows <= 0) | (cur_row < in_nrows); cur_row++) {
710 >        for (cur_row = row0; (in_nrows <= 0) | (cur_row < in_nrows); cur_row += rstep) {
711              RMATRIX     *mres = NULL;
712 <            for (i = 0; i < nmats; i++) {
712 >            for (i = 0; i < nmats; i++)
713                  if (!rmx_load_row(mop[i].imx.mtx, &mop[i].imx, mop[i].infp)) {
714                          if (cur_row > in_nrows) /* unknown #input rows? */
715 <                                goto loop_exit;
715 >                                break;
716                          fprintf(stderr, "%s: read error at row %d\n",
717                                          mop[i].inspec, cur_row);
718                          return(0);
719                  }
720 +            if (i < nmats)
721 +                break;
722 +            for (i = 0; i < nmats; i++)
723                  if (!apply_op(mop[i].rmp, &mop[i].imx, &mop[i].preop))
724                          return(0);
602 –            }
725              if (set_r) varset("r", '=', cur_row);
726              for (cur_col = 0; cur_col < in_ncols; cur_col++) {
727                  if (set_c) varset("c", '=', cur_col);
# Line 636 | Line 758 | combine_input(ROPMAT *res, FILE *fout)
758                          return(0);
759              }
760              rmx_free(mres); mres = NULL;
761 +            if (inchild >= 0) {
762 +                i = getc(stdin);        /* child waits for turn to output */
763 +                if (i != EOF) ungetc(i, stdin);
764 +            }
765              if (!rmx_write_data(res->rmp->mtx, res->rmp->ncomp,
766 <                                res->rmp->ncols, res->rmp->dtype, fout))
766 >                                res->rmp->ncols, res->rmp->dtype, stdout))
767                  return(0);
768 +            if (inchild >= 0 && fflush(stdout) == EOF)
769 +                return(0);
770          }
771 < loop_exit:
644 < #if 0           /* we're about to exit, so who cares? */
645 <        rmx_free(tmp);                  /* clean up */
646 <        rmx_reset(res->rmp);
647 <        rmx_reset(&res->imx);
648 <        for (i = 0; i < nmats; i++) {
649 <                rmx_reset(mop[i].rmp);
650 <                rmx_reset(&mop[i].imx);
651 <                if (mop[i].inspec[0] == '!')
652 <                        pclose(mop[i].infp);
653 <                else if (mop[i].inspec != stdin_name)
654 <                        fclose(mop[i].infp);
655 <                mop[i].infp = NULL;
656 <        }
657 < #endif
658 <        return(fflush(fout) != EOF);
771 >        return(inchild >= 0 || fflush(stdout) != EOF);
772   memerror:
773          fputs("Out of buffer space in combine_input()\n", stderr);
774          return(0);
# Line 705 | Line 818 | main(int argc, char *argv[])
818          const char      *defCsym = NULL;
819          int             echoheader = 1;
820          int             stdin_used = 0;
821 +        int             nproc = 1;
822          const char      *mcat_spec = NULL;
823          int             n2comp = 0;
824          uby8            comp_ndx[128];
# Line 732 | Line 846 | main(int argc, char *argv[])
846                          case 'h':
847                                  echoheader = !echoheader;
848                                  break;
849 +                        case 'n':
850 +                                nproc = atoi(argv[++i]);
851 +                                if (nproc <= 0)
852 +                                        goto userr;
853 +                                break;
854                          case 'e':
855                                  if (!n) goto userr;
856                                  comp_ndx[n2comp++] = i++;
# Line 870 | Line 989 | main(int argc, char *argv[])
989                  return(1);
990          }
991          doptimize(1);                   /* optimize definitions */
992 +        if (spawned_children(nproc))    /* running in children? */
993 +                return(parent_loop() ? 0 : 1);
994                                          /* process & write rows */
995 <        return(combine_input(&mop[nmats], stdout) ? 0 : 1);
995 >        return(combine_input() ? 0 : 1);
996   stdin_error:
997          fprintf(stderr, "%s: %s used for more than one input\n",
998                          argv[0], stdin_name);
999          return(1);
1000   userr:
1001          fprintf(stderr,
1002 <        "Usage: %s [-h][-f{adfc}][-e expr][-f file][-s sf .. | -c ce ..] m1 .. -m mcat > mres\n",
1002 >        "Usage: %s [-h][-f{adfc}][-n nproc][-e expr][-f file][-s sf .. | -c ce ..] m1 .. -m mcat > mres\n",
1003                          argv[0]);
1004          return(1);
1005   }

Diff Legend

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