qmake.1

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 GNU make,
       version 3.82 ("gmake).  Both Grid Engine and GNU make command line
       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 command
       line options.  The GNU Make manual (via info) or 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 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 Grid Engine environment is not set
       up in the user's .cshrc Or .profile shell resource file, and also
       request slots in a parallel environment (see sge_pe(5)).

       If no resource request (Grid Engine command line option -l) is
       specified, qmake will use the environment variable SGE_ARCH to request
       the same architecture as the submit host for task execution.  If
       SGE_ARCH is set, the architecture 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 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 Grid Engine.  The make rules are executed as tasks
              within this parallel job.

       2.     Dynamic allocation of resources. If no parallel environment 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 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 - presumably 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
       machine 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, and as as many parallel tasks will execute 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 maximum 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 command 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 submitted above
       under parallel environment "make".

ENVIRONMENT 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 environment, qmake will request
                      the given architecture for job execution (see
                      DESCRIPTION above).

KNOWN PROBLEMS

   Slow NFS server
       Very low file server performance may lead to problems on dependent
       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:
                     cc -c x.c
                     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 following instead:

              libx.a:
                     cc -c x.c ; ar ru libx.a x.o

       or

              libx.a:
                     cc -c x.c ; \
                     ar ru libx.a x.o

SEE ALSO

       submit(1), sge_pe(5), as well as make(1) (GNU make manpage) and
       TheGNUMakeManual via info(1).

COPYRIGHT

       Qmake Is based on GNU Make (gmake), which is copyright by 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>/doc/LICENCES for a statement of further rights and
       permissions.



SGE 8.1.3pre                      2011-05-20                          QMAKE(1)