    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 ARCH
         to request the same architecture for task execution  as  has
         the submit host.  If ARCH is set, the architecture specified
         in ARCH  will  be  requested  by  inserting  the  option  -l
         arch=$ARCH  into  the  commandline  options.  If ARCH is not
         set, the make tasks can be executed on any available  archi-
         tecture.   As  this  is  critical for typical make (compile)
         jobs, a warning will be output.

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

         will request between 1 and 10 slots in parallel  environment
         "compiling" on the same architecture as the submit host. The
         make tasks will inherit the complete environment of the cal-
         ling  shell. It will execute as many parallel tasks as slots
         have been granted by Grid Engine.

              qmake -cwd -v PATH -- -j 4

         will request between 1 and 4 slots in  parallel  environment
         "make" on the same architecture as the submit host.
              qmake -cwd -v PATH -l arch=solaris -pe make 3

         will request 3 parallel make tasks to be executed  on  hosts
         of  architecture "solaris". 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.

         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).

         COMMD_PORT     If set,  specifies  the  tcp  port  on  which
                        sge_commd(8)  is  expected to listen for com-
                        munication requests.  Most installations will
                        use  a  services  map entry instead to define
                        that port.

         COMMD_HOST     If set, specifies the host on which the  par-
                        ticular  sge_commd(8)  to  be  used  for Grid
                        Engine  communication  of  the  qmake  client
                        resides.  Per default the local host is used.

    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.