DOKK / manpages / debian 10 / gridengine-client / qmake_sge.1.en
QMAKE(1) Grid Engine User Commands QMAKE(1)

qmake - distributed parallel make, scheduling by Grid Engine.

qmake [options] -- [gmake options]

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. 

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









  

  
Specifies the location of the Grid Engine standard configuration
    files.

  

  
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.









  

  
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.

  

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














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.








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
















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








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.







  

    2011-05-20
    SGE 8.1.3pre