--- name: "qmake_sge" section: "1" platform: "linux" package: "gridengine-client" version: "8.1.9+dfsg-13.1" release: "Debian 13 (Trixie)" platforms: ["linux"] url: "https://new.carta.tech/qmake_sge" --- # qmake\_sge(1) distributed parallel make, scheduling by Grid Engine. ## NAME qmake - distributed parallel make, scheduling by Grid Engine. ## SYNTAX **qmake** \[*options*\] -- \[*gmake options*\] ## DESCRIPTION *Qmake* is a parallel, distributed [*make*(1)](/make/1.md) 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)](/qsub/1.md) or [*qrsh*(1)](/qrsh/1.md) 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)](/make/1.md) 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)](/sge_pe/5.md)). 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]