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.
Man(1) output converted with
man2html