qmake - distributed parallel make, scheduling by Sun Grid
qmake [ options ] -- [ gmake options ]
Qmake is a parallel, distributed make(1) utility. Scheduling
of the parallel make tasks is done by Sun Grid Engine. It is
based on gmake (GNU make), version 3.78.1. Both Sun Grid
Engine and gmake command line options can be specified. They
are separated by "--".
All Sun Grid Engine options valid with qsub(1) or qrsh(1)
can be specified with qmake - see submit(1) for a descrip-
tion of all Sun Grid Engine command line options. 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 Sun 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 Sun Grid Engine environment is not setup in the users
.cshrc or .profile shell resource file and request slots in
a parallel environment (see sge_pe(5) ).
If no resource request (Sun Grid Engine command line 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 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 Sun 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 Sun Grid Engine. The make rules are
executed as tasks within 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 Sun 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 - 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 machines 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.
It will execute as many parallel tasks as slots have been
granted by Sun 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-
mand 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.
rm -f test main.o functions.o
test: main.o functions.o
SGE_RREQ="-l link=1" ld -o test main.o functions.o
SGE_RREQ="-l comp=1" cc -c -DALIASPATH=
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
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 submit-
ted above under parallel environment "make".
SGE_ROOT Specifies the location of the Sun Grid Engine
standard configuration files.
SGE_CELL If set, specifies the default Sun Grid Engine
cell. To address a Sun 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
The name of the default cell, i.e.
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
Slow NFS server
Very low file server performance may lead to problems on
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.
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-
cd x ; ar ru libx.a x.o
cd x ; \
ar ru libx.a x.o
submit(1) , sge_pe(5) as well as make(1) (GNU make manpage)
and The GNU Make Manual in <sge_root>/3rd_party/qmake.
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
Man(1) output converted with