    NAME
         qmake  -  distributed  parallel  make,  scheduling  by  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 Grid Engine. It is
         based on gmake (GNU make), version 3.78.1. Both Grid  Engine
         and  gmake  commandline  options  can be specified. They are
         separated by "--".

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

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

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

         If no resource request (Grid Engine commandline  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 commandline 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  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 commandline, a parallel
         job is scheduled by Grid Engine.  The make  rules  are  exe-
         cuted as tasks withing 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 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 preceeding 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 commandline 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 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-
         mandline,  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 commandline.

              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 commandline
              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 [furter sge options] <script>

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

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

         SGE_CELL       If set, specifies  the  default  Grid  Engine
                        cell.  To  address  a  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 commandline.

         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.