SYNTAX
qmake [ options ] -- [ gmake options ]
DESCRIPTION
Qmake is a parallel, distributed make(1) utility. Scheduling of the
parallel make tasks is done by Univa Grid Engine. It is based on gmake
(GNU make), version 3.78.1. Both Univa Grid Engine and gmake command
line options can be specified. They are separated by "--".
All Univa Grid Engine options valid with qsub(1) or qrsh(1) can be
specified with qmake - see submit(1) for a description of all Univa
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 Univa 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 Univa Grid Engine envi-
ronment 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 (Univa 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 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 Univa 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 Univa 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 Univa 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,
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 architec-
ture "sol-sparc64". The submit may be done on a host of any architec-
ture.
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".
ENVIRONMENTAL VARIABLES
SGE_ROOT Specifies the location of the Univa Grid Engine standard
configuration files.
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 DESCRIP-
TION 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 perfor-
mance, 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:
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 following 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 per-
missions.
UGE 8.0.0 $Date: 2007/07/19 09:04:30 $ QMAKE(1)
Man(1) output converted with
man2html