    NAME
         qmake - distributed parallel make, scheduling  by  Sun  Grid
         Engine.

    SYNTAX
         qmake [ options ] -- [ gmake options ]

    DESCRIPTION
         Qmake is a parallel, distributed make(1) utility. Scheduling
         of the parallel make tasks is done by Sun Grid Engine. It is
         based on gmake (GNU make), version  3.78.1.  Both  Sun  Grid
         Engine and gmake command line options can be specified. They
         are separated by "--".

         All Sun Grid Engine options valid with  qsub(1)  or  qrsh(1)
         can  be  specified with qmake - see submit(1) for a descrip-
         tion of all Sun  Grid  Engine  command  line  options.   The
         make(1) manual page describes the gmake command line syntax.

         The syntax of qmake makefiles corresponds to  gmake  and  is
         described in the "GNU Make Manual".

         A typical qmake call will use the Sun  Grid  Engine  command
         line  options  -cwd  to have a scheduled make started in the
         current working directory on the execution host, -v PATH  if
         the  Sun  Grid  Engine environment is not setup in the users
         .cshrc or .profile shell resource file and request slots  in
         a parallel environment (see sge_pe(5) ).

         If no resource request (Sun Grid Engine command line  option
         -l)  is  specified,  qmake will use the environment variable
         SGE_ARCH to request the same architecture for task execution
         as  has  the submit host.  If SGE_ARCH is set, the architec-
         ture specified in SGE_ARCH will be  requested  by  inserting
         the  option -l arch=$SGE_ARCH into the command line options.
         If SGE_ARCH is not set, the make tasks can  be  executed  on
         any available architecture.  As this is critical for typical
         make (compile) jobs, a warning will be output.

         qmake has two different modes for allocating Sun Grid Engine
         resources for the parallel execution of tasks:

         1. Allocation of resources using a parallel environment.  If
         the -pe option is used on the qmake command line, a parallel
         job is scheduled by Sun Grid Engine.   The  make  rules  are
         executed as tasks within this parallel job.

         2. Dynamic allocation of resources. If no parallel  environ-
         ment  is  requested  when  submitting a qmake job, each make
         rule will generate an individual Sun Grid Engine  qrsh  job.
         All  resource  requests  given to qmake will be inherited by
         the jobs processing the make rules.
         In dynamic allocation mode, additional resource requests for
         individual  rules  can be specified by preceding the rule by
         the definition of an environment variable SGE_RREQ. The rule
         then   takes  the  form  SGE_RREQ="<request>"  <rule>,  e.g.
         SGE_RREQ="-l lic=1" cc -c ...  If such  makefile  rules  are
         executed in a make utility other than qmake, the environment
         variable SGE_RREQ will be set in the environment established
         for the rule's execution - without any effect.

    EXAMPLES
              qmake -cwd -v PATH -pe compiling 1-10 --

         will request between 1 and 10 slots in parallel  environment
         "compiling".  If the SGE_ARCH environment variable is set to
         the  machines  architecture,  a  resource  request  will  be
         inserted  into the qmake command line to start the qmake job
         on the same architecture as the submit host. The make  tasks
         will  inherit the complete environment of the calling shell.
         It will execute as many parallel tasks as  slots  have  been
         granted by Sun Grid Engine.

              qmake -l arch=sol-sparc -cwd -v PATH -- -j 4

         will submit each make rule as an individual qrsh job. A max-
         imum  of  4  tasks will be processed in parallel.  The qmake
         job will be started on a machine of architecture  sol-sparc,
         this  resource  request  will  also be inherited by the make
         tasks, i.e. all jobs created for the execution of make tasks
         will request the architecture sol-sparc.

         If the following Makefile is submitted with the  above  com-
         mand  line,  additional  resource  requests will be made for
         individual rules:  For the compile and link rules,  compiler
         licenses   (comp)   and   linker  licenses  (link)  will  be
         requested, in addition to the resource request made for  the
         whole job (-l arch=sol-sparc) on the command line.

              all: test

              clean:
                   rm -f test main.o functions.o

              test: main.o functions.o
                   SGE_RREQ="-l link=1" ld -o test main.o functions.o

              main.o: main.c
                   SGE_RREQ="-l comp=1" cc -c -DALIASPATH=

              functions.o: functions.c
                   SGE_RREQ="-l comp=1" cc -c -DALIASPATH=

         The command line
              qmake -cwd -v PATH -l arch=sol-sparc64 -pe make 3 --

         will request 3 parallel make tasks to be executed  on  hosts
         of  architecture  "sol-sparc64". The submit may be done on a
         host of any architecture.

         The shell script

              #!/bin/sh
              qmake -inherit --

         can be submitted by

              qsub -cwd -v PATH -pe make 1-10 [further sge options] <script>

         Qmake will inherit the resources granted for the job submit-
         ted above under parallel environment "make".

    ENVIRONMENTAL VARIABLES
         SGE_ROOT       Specifies the location of the Sun Grid Engine
                        standard configuration files.

         SGE_CELL       If set, specifies the default Sun Grid Engine
                        cell. To address a Sun Grid Engine cell qmake
                        uses (in the order of precedence):

                             The name of the cell  specified  in  the
                             environment  variable SGE_CELL, if it is
                             set.

                             The  name  of  the  default  cell,  i.e.
                             default.

         SGE_DEBUG_LEVEL
                        If  set,  specifies  that  debug  information
                        should  be written to stderr. In addition the
                        level of detail in which debug information is
                        generated is defined.

         SGE_ARCH       The architecture of the submit host. If  this
                        variable  is  set  in the submission environ-
                        ment, qmake will request the given  architec-
                        ture   for  job  execution  (see  DESCRIPTION
                        above).

    KNOWN PROBLEMS
      Slow NFS server
         Very low file server performance may  lead  to  problems  on
         depending files.

         Example: Host a compiles a.c to a.o, host b compiles b.c  to
         b.o,  host  c shall link program c from a.o and b.o. In case
         of very bad NFS performance, host c might not yet see  files
         a.o and b.o.

      Multiple commands in one rule
         If multiple commands are executed in one rule, the  makefile
         has to ensure that they are handled as one command line.

         Example:

              libx.a:
                   cd x
                   ar ru libx.a x.o

         Building libx.a will fail, if the commands are  executed  in
         parallel  (and  possibly on different hosts). Write the fol-
         lowing instead:

              libx.a:
                   cd x ; ar ru libx.a x.o

         or

              libx.a:
                   cd x ; \
                   ar ru libx.a x.o

    SEE ALSO
         submit(1) , sge_pe(5) as well as make(1) (GNU make  manpage)
         and The GNU Make Manual in <sge_root>/3rd_party/qmake.

    COPYRIGHT
         Qmake contains portions of Gnu Make (gmake),  which  is  the
         copyright of the Free Software Foundation, Inc., Boston, MA,
         and is protected by the Gnu General Public License.
         See   sge_intro(1)   and   the   information   provided   in
         <sge_root>/3rd_party/qmake for a statement of further rights
         and permissions.