SUBDIRS - handling dependencies

Introduction

It is common for larger software projects to separate its components into different topics. There might be components the are relevant to the GUI of a software, other might be in the topic of handling geometrical processing, others are in the topic of generating a report.

Typically the software components belonging to a topic are combined into a software library (Wikipedia). In Windows these libraries are often found as .lib or .dll files; under Linux there are .a and .so files; under MacOS X they are called .a or .dylib files.

Finally these libraries are linked to an executable application.

The following text uses a small example, consisting of an application: app and two libraries: lib and lib2. The application app uses features of the libraries lib and lib2 while the libraries are in no direct relation. So, to have a running application the toolchain must create the lib.lib and lib2.lib files and finally create the app.exe by linking the lib.lib and lib2.lib to the object files of the app components. (The following Text uses the Windows file name notations of the objects)

When the software project is in an early design and implementation phase, the libraries might change as often as the application using the libraries. In the Qt domain, each of the three topics: lib, lib2 and app will be handled bye one project each. Typically there will be three folders: lib, lib2 and app, each containing a specific .pro file, describing how to handle each project (which source files, compile parameters, ...). The profiles typically will be named after the folders they live in: lib.pro, lib2.pro and app.pro. For this example all three projects will live in one folder: src.

On the file system this can be seen as following hierarchy:

 /src
 |--- app
 |    |--- app.pro
 |    `--- ... (source files of app)
 |--- lib
 |    |--- lib.pro
 |    `--- ... (source files of lib)
 `--- lib2
      |--- lib2.pro
      `--- ... (source files of lib2)
 

Each of this projects could for example be edited separately in three Microsoft Visual Studio 2010 IDEs (MSVS2010) or handled as three separate projects in one QtCreator. But this handling of the projects would mean to compile each by hand separately. It gets tedious when taking into account the dependencies between the three projects: the libs must be compiled before the app can be created!

template: subdirs

To handle this relation automatically qmake has a template type: subdirs (template).

The basic idea of this template type is, to list all projects that belong to a kind of meta project. A new .pro file is created for that meta project, that simply consists of the qmake system variable SUBDIRS. This variable is filled with the names of the project folders by giving the relative path to where the meta .pro file lies. In the following text this meta profile is names subdirs.pro. For a better overview in the file hierarchy a new parent folder is introduced, named after the software project that is created: FooApp.

 /FooApp
 |--- subdirs.pro
 `--- src
      |
      |--- app
      |    |--- app.pro
      |    `--- ... (source files of app)
      |--- lib
      |    |--- lib.pro
      |    `--- ... (source files of lib)
      `--- lib2
           |--- lib2.pro
           `--- ... (source files of lib2)
 

The meta profile subdirs.pro is on the same level as the src folder.

The content of the subdirs.pro is

 template = subdirs

 SUBDIRS = \
           src/app \   # relative paths
           src/lib \
           src/lib2
 

The subdirs.pro file can be opened by QtCreator. In QtCreator there will be just one project with child elements, the sub-project. The advantage is now that when compiling this meta project the sub-projects are compiled automatically. Asking for a qmake run within QtCreator on this meta project will also recurse into the sub-projects calling qmake for each.

To make this meta project available for MSVC2010, qmake must be called on the command line in the folder FooApp:

qmake -tp vc -r

This will generate a solution file with the name subdirs.sln. When opening this file in MSVC2010 a solution will be opened that contain the three project: app, lib, and lib2. A compile on the solution will call compile for each of the contained projects.

Attention: The order in with the subproject are compiled is not defined by the SUBDIRS content. And this could lead to a wrong processing order. So, the app project could not be build if it is processed first; it would miss the libraries lib and lib2. One could assume that the build order is given by the order of the entities in the SUBDIRS variable (so example given above would be wrong). But many modern compile tools offer parallel compilation. If the order of the entity would be forcing the build order, then parallel compilation on the projects level would not be possible. Per default the sub-projects are compiled in any order the used build-systems logic prefers.

Defining Project Dependencies: .depends attributes

To support parallel processing of the projects on modern computers, an additional information must be given: Which project must be finished before another project can be processed.

In the running example, we have noted that app can only be build, when lib and lib2 are build.

By telling the dependency explicitly in the meta project file, qmake can build processing instructions that allow a high degree of parallelism.

 template = subdirs

 SUBDIRS = \
           lib2 \   # sub-project names
           lib  \
           app

 # where to find the sub projects - give the folders
 lib2.subdir = src/lib2
 lib.subdir  = src/lib
 app.subdir  = src/app

 # what subproject depends on others
 app.depends = lib lib2
 

The important addition to the file is the line app.depends = lib lib2. Setting the .depends attribute of the project app tells qmake that app can only be build if lib and lib2 is processed.

This allows qmake to build processing instructions that can be executed in a high degree of parallelism. For example lib and lib2 can be build in parallel, while app is hold back until lib and lib2 processing is finished.

In addition there is an implicit introduction of projects names. In SUBDIRS the project names are given (not the path anymore). The path to the project directory is set below by setting the .subdir attribute to the relative path where the project folder is located.

Defining a processing sequence: CONFIG += ordered

With this option the processing of the sub-project can be set to follow the order in which they are listed in the SUBDIRS variable.

 template = subdirs

 SUBDIRS = \
           src/lib2\   
           src/lib \
           src/app

 # build the project sequentially as listed in SUBDIRS !
 CONFIG += ordered
 

By having the listing order: src/lib2, src/lib, src/app the build tool will follow that order and build the project one at a time. Due to processing in this strict project order the build dependencies are implicitly fulfilled, as long as the listing order is chosen right.

But the processing "one at a time" eliminates the possibility to process independent projects in parallel. However each projects might process in parallel in its local context - e.g. the .cpp files within lib2 might get compiled in parallel.

Background on Windows Build Systems

There are different ways to process a project (or meta project) under windows.

Makefiles

There are command line tools to compile project with the help of a compile rule file: a Makefile (wikipedia).

For a meta-project, qmake must be called with the recursive option in the FooApp folder, the one with the subdirs.pro file:

qmake -r

This will generate a Makefile in the same directory. In addition qmake will process all the subdirs given in the SUBDIRS variable and create Makefiles in each of the sub-project folders, containing rules to create the sub-project.

 /FooApp
 |--- Makefile
 |--- subdirs.pro
 `--- src
      |
      |--- app
      |    |--- app.pro
      |    |--- Makefile
      |    |--- Makefile.Debug
      |    |--- Makefile.Release
      |    `--- ... (source files of app)
      |--- lib
      |    |--- lib.pro
      |    |--- Makefile
      |    |--- Makefile.Debug
      |    |--- Makefile.Release
      |    `--- ... (source files of lib)
      `--- lib2
           |--- lib2.pro
           |--- Makefile
           |--- Makefile.Debug
           |--- Makefile.Release
           `--- ... (source files of lib2)
 

nmake

The windows nmake tool reads a Windows Makefile that was generated by qmake. nmake will understand the rules in the Makefile and will call the compiler and linker to build the libraries and application.

Calling nmake in the meta project folder FooApp via

nmake

will find the Makefile and will process it. As this Makefile is one for a meta-project, it contains rules to process the Makefiles of the sub-project.

nmake has no feature to call compile or link in parallel. An option "-j <n>" as known with Unix make or gnumake does not exist. So nmake start project after project and in each project compiles file after file. Probably the listing order of the sub-projects within the SUBDIRS variable will be used. But this is nothing to rely on! How to determine the processing order sufficiently is shown in the chapters above.

jom

The missing parallel execution feature of nmake is inefficient on modern computer architectures. With CPUs having many kernels for parallelism and fast storage units, a modern computer is bored by using nmake and project compilation takes longer as it could take. This lead to the creation of a new make tool: Jom. jom is basically an nmake clone extended with the '/J <n>' option to compile in parallel. To compile a meta projects Makefile the call has to be

jom

in the FooApp folder. jom will recurse automatically in the sub-project folders and use the Makefile of the sub-folders. But all in a parallel fashion. To see the dependency graph that jom processes, the command

jom /DUMPGRAPH

can be called. For the insufficient and wrongly ordered example

 template = subdirs

 SUBDIRS = \
           src/app \   # relative paths
           src/lib \
           src/lib2
 

the output of jom is

first
 make_first
  sub-src-app-make_first
   FORCE
  sub-src-lib-make_first
   FORCE
  sub-src-lib2-make_first
   FORCE
  FORCE
 

All three sub-src-xxx-make_first are on the same level and they have no dependency under it (aside from FORCE). So all is build in parallel if the number of kernels is high enough. The parallel processing might result in a build error due to race conditions: The linker of the app project could be started even though the necessary libraries are not build already!

For an example with dependency given explicitly:

 template = subdirs

 SUBDIRS = \
           lib2 \   # sub-project names
           lib  \
           app

 # where to find the sub projects - give the folders
 lib2.subdir = src/lib2
 lib.subdir  = src/lib
 app.subdir  = src/app

 # what subproject depends on others
 app.depends = lib lib2
 

jom output for the graph:

first
 make_first
  sub-src-lib-make_first
   FORCE
  sub-src-lib2-make_first
   FORCE
  sub-src-app-make_first
   sub-src-lib-make_first
    FORCE
   sub-src-lib2-make_first
    FORCE
   FORCE
  FORCE
 

Here sub-src-app-make_first depends on sub-src-lib-make_first and sub-src-lib2-make_first. So lib and lib2 must first be build before app can be processed. Here lib and lib2 can even be processed in parallel, they have no dependencies.

Finally for the sequential case

 template = subdirs

 SUBDIRS = \
           src/lib2\   
           src/lib \
           src/app

 # build the project sequentially as listed in SUBDIRS !
 CONFIG += ordered
 

jom's output for the graph is:

first
 make_first
  sub-src-lib2-make_first-ordered
   FORCE
  sub-src-lib-make_first-ordered
   sub-src-lib2-make_first-ordered
    FORCE
   FORCE
  sub-src-app-make_first-ordered
   sub-src-lib-make_first-ordered
    sub-src-lib2-make_first-ordered
     FORCE
    FORCE
   FORCE
  FORCE
 

So app can be build if lib was build and lib can be build if lib2 was build: first lib2, then lib, then app. No parallelism on the project level is possible.

With

jom /J 10

ten parallel compiles will be started if enough independent compiles are found.

.sln files / .vcxproj files

The standard Microsoft Visual Studio toolchain does not use Makefiles. The toolchain needs a solution file (.sln) and one ore more project files (.vcxproj). The solution is again a kind of meta project collecting the project a solution consists of. These files can be processed by the Microsoft Visual Studio C++ IDE (MSVC2010) or with the msbuild tool as a command line tool.

qmake can also generate these files, to make it possible to use this IDE. To have this generated

 gmake -tp vc -r
 

must be called in the FooApp folder containing the meta project subdirs.pro project file. gmake will create a .sln file in the same FooApp folder. qmake will also go into the SUBDIRS project folders and generate .vcxproj files that are refered to in the .sln file. In MSVS2010 IDE the .sln file can be opened a a listing of subdir projects will be listed. For the running example the file would be names: subdirs.sln, app.vcxproj, lib.vcxproj, and lib2.vcxproj.

With the explicit dependency giving subdir.pro file

 template = subdirs

 SUBDIRS = \
           lib2 \   # sub-project names
           lib  \
           app

 # where to find the sub projects - give the folders
 lib2.subdir = src/lib2
 lib.subdir  = src/lib
 app.subdir  = src/app

 # what subproject depends on others
 app.depends = lib lib2
 

solution and project files will be generated that reflect these dependencies.

Microsoft Visual Studio IDE

Within the IDE the solution properties contain a section "Common Properties" and in this a subsection "Project Dependencies". This subsection has a combo box to choose a project. All project this chosen on depends on are checked in the listing below.

app depends on lib and lib2

This dependency constellation can also be checked in the .sln file.

Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib", "C:/Users/Michael/QtProgramme/subdirs_test/src/lib\lib.vcxproj", "{BBD7705B-EE58-39F5-9DA4-17D53DE9F205}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lib2", "C:/Users/Michael/QtProgramme/subdirs_test/src/lib2\lib2.vcxproj", "{E2C38A45-30F3-3D3D-9D94-91EB9244EAF6}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "app", "C:/Users/Michael/QtProgramme/subdirs_test/src/app\app.vcxproj", "{124A643E-E033-36E6-AA41-AD3E268A86DE}"
	ProjectSection(ProjectDependencies) = postProject
		{BBD7705B-EE58-39F5-9DA4-17D53DE9F205} = {BBD7705B-EE58-39F5-9DA4-17D53DE9F205}
		{E2C38A45-30F3-3D3D-9D94-91EB9244EAF6} = {E2C38A45-30F3-3D3D-9D94-91EB9244EAF6}
	EndProjectSection
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Win32 = Debug|Win32
		Release|Win32 = Release|Win32
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{BBD7705B-EE58-39F5-9DA4-17D53DE9F205}.Debug|Win32.ActiveCfg = Debug|Win32
		{BBD7705B-EE58-39F5-9DA4-17D53DE9F205}.Debug|Win32.Build.0 = Debug|Win32
		{BBD7705B-EE58-39F5-9DA4-17D53DE9F205}.Release|Win32.ActiveCfg = Release|Win32
		{BBD7705B-EE58-39F5-9DA4-17D53DE9F205}.Release|Win32.Build.0 = Release|Win32
		{E2C38A45-30F3-3D3D-9D94-91EB9244EAF6}.Debug|Win32.ActiveCfg = Debug|Win32
		{E2C38A45-30F3-3D3D-9D94-91EB9244EAF6}.Debug|Win32.Build.0 = Debug|Win32
		{E2C38A45-30F3-3D3D-9D94-91EB9244EAF6}.Release|Win32.ActiveCfg = Release|Win32
		{E2C38A45-30F3-3D3D-9D94-91EB9244EAF6}.Release|Win32.Build.0 = Release|Win32
		{124A643E-E033-36E6-AA41-AD3E268A86DE}.Debug|Win32.ActiveCfg = Debug|Win32
		{124A643E-E033-36E6-AA41-AD3E268A86DE}.Debug|Win32.Build.0 = Debug|Win32
		{124A643E-E033-36E6-AA41-AD3E268A86DE}.Release|Win32.ActiveCfg = Release|Win32
		{124A643E-E033-36E6-AA41-AD3E268A86DE}.Release|Win32.Build.0 = Release|Win32
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
	EndGlobalSection
	GlobalSection(ExtensibilityAddIns) = postSolution
	EndGlobalSection
EndGlobal

In the project app there is a section to describe the dependency.

ProjectSection(ProjectDependencies) = postProject
		{BBD7705B-EE58-39F5-9DA4-17D53DE9F205} = {BBD7705B-EE58-39F5-9DA4-17D53DE9F205}
		{E2C38A45-30F3-3D3D-9D94-91EB9244EAF6} = {E2C38A45-30F3-3D3D-9D94-91EB9244EAF6}
	EndProjectSection

Such a solution can be build from within the IDE. Within the IDE the projects are processed in parallel, respecting the dependencies.

In the build output window there will be something like

 1>------ Rebuild All started: Project: lib2, Configuration: Debug Win32 ------
 2>------ Rebuild All started: Project: lib, Configuration: Debug Win32 ------
 1>  lib2.cpp
 2>  lib.cpp
 1>     Creating library debug\\lib2d.lib and object debug\\lib2d.exp
 2>     Creating library debug\\libd.lib and object debug\\libd.exp
 1>  lib2.vcxproj -> C:\Users\Michael\QtProgramme\subdirs_test\src\lib2\debug\lib2d.dll
 2>  lib.vcxproj -> C:\Users\Michael\QtProgramme\subdirs_test\src\lib\debug\libd.dll
 3>------ Rebuild All started: Project: app, Configuration: Debug Win32 ------
 3>  main.cpp
 3>  app.vcxproj -> C:\Users\Michael\QtProgramme\subdirs_test\src\app\debug\app.exe
 

The parallelism in processing lib and lib2 can be seen very well. After lib and lib2 finishes processing of app starts.

msbuild

From the command line the tool msbuild can be used to process the solution. In the FooApp folder, where the .sln file was generated, a call

 msbuild

will process the solution file.

By default msbuild does not process in any parallel fashion. But similarly to joms "/J <n>" option msbuild has the "/m:<n>" option. When calling

 msbuild /m:4

maximal four cores of the computer will be used to parallelize the processing of the solution.

msbuild has many command line options. For example, to let msbuild construct the release version the command

 msbuild /p:Configuration=Release

must be called.

to be continued....

--Moellney (talk) 22:30, 18 April 2015 (UTC)