These steps may include:

Size: px

Start display at page:

Download "These steps may include:"

Merry Hampton
5 years ago
Views:

1 Build Tools 1

2 Build Tools Building a program for a large project is usually managed by a build tool that controls the various steps involved. These steps may include: 1. Compiling source code to binaries 2. Linking to binaries or libraries 3. Running software tests 4. Creating different build targets 5. Generating documentation 2

3 Build Tools There are a number of different build automation tools available. Make Automake CMake Apache Ant 3

4 Make The make utility is a commonly used build tool that can manage the process of building and rebuilding a project. Make was originally written in 1976 by Stuart Feldman, who received the 2003 ACM Software System award for his work. For MAKE there is probably no large software system in the world today that has not been processed by a version or offspring of MAKE. 4

5 Make Make is similar to a declarative programming language in that it describes the conditions for certain command but not the order in which they should be executed. This can sometimes cause confusion for programmers who are used to imperative programming. 5

6 Make A makesile consists of a set of rules. Each of these rules has a textual dependency line which desines the target of the rule as well as a optional set of dependencies: target: depenency1 command1 command2 6

7 Make Example manual compilation: main.cpp class1.cpp class2.cpp $ g++ main.cpp class1.cpp class2.cpp o main $./main Manually compile all Siles using gcc from the command line. 7

8 Make Example simple makesile: all: g++ main.cpp class1.cpp class2.cpp o main $ g++ main.cpp class1.cpp class2.cpp o main $./main MakeSile with a single (default) target that compiles all the Siles. 8

9 Make Example MakeSile with dependencies all: main main: main.o class1.o class2.o g++ main.o class1.o class2.o o main main.o: main.cpp class1.o: g++ -c main.cpp g++ -c class1.cpp class2.o: g++ -c class2.cpp MakeSile that considers each Sile and dependencies and recompiles only if necessary. 9

10 Make Example MakeSile with clean clean: rm rf *o main $ make clean $ make $./main MakeSiles often contain a clean target that can be used to completely clean the project of all compiled Siles and completely rebuild from scratch. 10

11 Make Example MakeSile using Macros # Comment Selecting g++ as the compiler CC=g++ all: main main: main.o class1.o class2.o $(CC) main.o class1.o class2.o o main main.o: main.cpp... $(CC) -c main.cpp Macros can be used in MakeSiles to easily switch between different options and avoid rewriting large sections. 11

12 Make The problem with writing makesiles like this is that they can require a lot of work to set up and maintain them. Each object Sile has its own rule and set of dependencies that must be updated. Another option is to use wildcards and Generic Rules. 12

13 Make Example MakeSile - Macros and Generic rules. # Comment Selecting g++ as the compiler CC=g++ SOURCES=$(wildcard *.cpp) OBJECTS=$(SOURCES:.cpp=.o) all: main main: $(OBJECTS) $(CC) $(OBJECTS) o main.cpp.o: $(CC) c $< -o $@ 13

14 Make This makesile is an improvement. The generic rules for generating object Siles from source Siles allows us to add/remove source Siles without changing the makesile. However, it doesn't take into account any dependencies based on header Siles. 14

15 Make Example MakeSile # Comment Selecting g++ as the compiler CC=g++ SOURCES=$(wildcard *.cpp) HEADERS=$(wildcard *.h) OBJECTS=$(SOURCES:.cpp=.o) all: main main: $(OBJECTS) $(CC) $(OBJECTS) o main %.o: %.cpp $(HEADERS) $(CC) c $< -o $@ 15

16 Make This makesile now ensures that header Siles are included in the dependencies but also included every header Sile as a dependency for every object Sile. Any change to any header Sile will cause the entire project to be recompiled. 16

17 Make Rather than this all- inclusive approach for dependencies, most C compilers can generate a set of dependencies for you using the '- M' Slag. This can be included into a makesile using -include 17

18 Make Example MakeSile # Comment Selecting g++ as the compiler CC=g++ SOURCES=$(wildcard *.cpp) HEADERS=$(wildcard *.h) OBJECTS=$(SOURCES:.cpp=.o) DEPS all: main =$(SOURCES:.cpp=.d) main: $(OBJECTS) $(CC) $(OBJECTS) o main %.o: %.cpp $(CC) c $*.cpp -o $*.o $(CC) M $*.cpp o $*.d -include $(DEPS) 18

19 Make This makesile generates a.d Sile for each.cpp Sile that contains the dependency rule for that.cpp Sile. This.d Sile is then included into the makesile with all of the dependency information for that Sile. If the.cpp Sile or any of the dependencies change, the.o Sile will be recompiled and will generate a new dependency Sile. 19

20 Make This allows us to write a makesile that will only recompile Siles that actually need to be recompiled (to ensure fast compile times) but also uses generic rules so we don't need to keep maintaining the makesile. 20

21 Make For more information see: 21

22 Make Make doesn't support cross- platform compilation directly but it can be supported to some degree by platform- specisic conditionals in the MakeSile. ifeq($(os), Windows) LIBS=-lopengl.dll else ifeq($(os), MAC) LIBS=-framework OpenGL else ifeq($(os), UBUNTU) endif LIBS=-lopengl 22

23 Automake Automake is a higher- level language that allows the programmer to avoid manually writing makesiles. For most simple cases it it enough to give the name of the program, a list of source Siles and a list of compile/link options. From this Automake can generate a makesile for your project. 23

24 Automake Automake is a part of a set of tools called The Autotools. These tools can automate some of the process of writing a Unix build system. This provides the user with a set of instructions:./configure make make install 24

25 Automake To generate makesiles with autotools, we write two Siles: Makefile.am: bin_programs = main main_sources = main.cpp class1.cpp class2.cpp configure.ac: AC_INIT([ammain], [1.0]) AM_INIT_AUTOMAKE AC_PROG_CXX AC_PROG_RANLIB AC_CONFIG_HEADERS([config.h]) AC_CONFIG_FILES([Makefile]) AC_OUTPUT 25

26 Automake To generate makesiles with autotools, we write two Siles: $ aclocal $ autoheader $ autoconf $ automake --add-missing This process generates the consigure script and makesile for the project. 26

27 Automake The project can then be built using: $./configure $ make To build the project on a different system, simply re- run consigure and then make the project. 27

28 Automake To generate and link to libraries: Makefile.am: noinst_libraries = libclass1.a libclass2.a libclass1_sources = class1.cpp libclass2_sources = class2.cpp bin_programs = main main_sources = main.cpp main_ldadd = libclass1.a libclass2.a 28

29 Automake For more information on Automake: 29

30 CMake CMake is the cross- platform, open- source build system designed to control the software compilation using platform and compiler independent consiguration Siles. This tool automatically generates build scripts for different operating systems - Visual Studio projects for Windows and makesiles for Unix/ Linux. 30

31 CMake CMake generates build scripts from Siles named: CMakeLists.txt These Siles must be put in each subdirectory of the project as required. 31

32 CMake Example Simple CMake cmake_minimum_required(version 2.6) project(main) add_executable(main main.cpp class1.cpp class2.cpp) $ cmake. -- The C compiler identification is Clang The CXX compiler identification is Clang Check for working C compiler: /usr/bin/cc -- Check for working C compiler: /usr/bin/cc -- works -- Detecting C compiler ABI info -- Detecting C compiler ABI info done... 32

33 Example Simple CMake CMake $ make Scanning dependencies of target Main [ 33%] Building CXX object CMakeFiles/Main.dir/main.cpp.o [ 66%] Building CXX object CMakeFiles/Main.dir/class1.cpp.o [100%] Building CXX object CMakeFiles/Main.dir/class2.cpp.o Linking CXX executable Main [100%] Built target Main 33

34 CMake Rather than giving CMake explicit commands for how to compile your program. Instead you give instructions of what you want it to build. 34

35 CMake Example CMake with separate libraries cmake_minimum_required(version 2.6) project(main) add_library(class1 class1.cpp) add_library(class2 class2.cpp) add_executable(main main.cpp) target_link_libraries(main class1 class2) 35

36 CMake Example CMake with separate directories./main.cpp./cmakelists.txt class1/class1.h class1/class1.cpp class1/cmakelists.txt class2/class2.h class2/class2.cpp class2/cmakelists.txt 36

37 CMake Example CMake with separate directories class1/cmakelists.txt add_library(class1 class1.cpp) class2/cmakelists.txt add_library(class2 class2.cpp)./cmakelists.txt project(main) include_directories("${main_source_dir}/class1") include_directories("${main_source_dir}/class2") add_subdirectory(class1) add_subdirectory(class2) add_executable(main main.cpp) target_link_libraries(main class1 class2) 37

38 CMake CMake will generate makesiles for each of the different directories along with the necessary code to: 1. Build each subdirectory 2. Include Siles from the subdirectories 3. Link binaries together 38

39 CMake CMake has support for Sinding packages and including/linking to them. This cross- platform support covers packages that have different names and methods of including/linking on different operating systems. 39

40 CMake Example CMake with packages project(main) add_executable(main main.cpp) find_package(opengl) include_directories(${opengl_include_dirs}) target_link_libraries(main ${OpenGL_LIBRARIES) 40

41 CMake For more information on CMake: 41

42 Apache Ant Apache Ant is a Java library for building large projects. It is used mainly for building Java Applications but does also have support for other languages such as C or C++. The build of a project is desined by an XML Sile called build.xml 42

43 Structure of build.xml: <project> Apache Ant <property name="src.dir" value="src"/> <property name="build.dir" value="$build"/> <property name="jar.dir" value="${build.dir}/jar"/> <target name="compile"> <mkdir dir="${classes.dir}"/> <javac srcdir="${src.dir}" destdir="${classes.dir}"/> </target> <target name="jar" depends="compile"> <mkdir dir="${jar.dir}"/> <jar destfile... /> </target> </project> 43

44 Advanced Build Automation As projects become larger and more complex, more advanced build tools have been required to manage working with such large projects. Automation of the build process extends beyond simply managing the compiling and linking of a program. 44

45 Advanced Build Automation Distributed build automation is still largely a compilation/linking feature that farms out the compilation of different parts of the program to multiple locations or cores. 45

46 Advanced Build Automation An advanced build tool will not only build the project but can perform a series of tasks and tests to catch problems early on. Scheduled builds Many projects have scheduled, (eg nightly) builds where the current version of the project is compiled each night and run through code tests to pick up any errors. Prevents errors in the code from propagating. 46

47 Advanced Build Automation Triggered builds Some projects may be triggered to be rebuilt each time any developer commits new code. Can immediately catch problems before they become part of the project. 47

48 Version Control This type of build automation usually assumes the use of a version control system. Version control allows multiple developers to work on the same project at the same time. CVS - Concurrent Versions System SVN Subversion Git 48

49 Version Control Trunk - A set of source code, resources etc making up a project. Basically the project. Branch - A branch splits from the trunk at some point in time, can be edited and updated separately. Used to try out ideas. Merging A successful branch can be merged back into the trunk. 49

50 Version Control Check out Creates a local copy of the project (specisic to a trunk or branch) from the repository. Commit Send your changes to the repository, creates a 'new version' of the project. 50

51 Version Control Version control software such as SVN is built using the client- server model where each client connects to a server that 'owns' the software repository. The server is responsible for accepting commits, it may 'lock' certain parts of the project etc. 51

52 Version Control Git is an example of a distributed version control system. Each user maintains a local copy which counts as a repository itself. Every user 'owns' the project as much as any other user or server. Changes can be pushed/pulled from any other copy of the project repository. 52

Build automation. CSE260, Computer Science B: Honors Stony Brook University

Build automation. CSE260, Computer Science B: Honors Stony Brook University Build automation CSE260, Computer Science B: Honors Stony Brook University http://www.cs.stonybrook.edu/~cse260 2 Build Automation Build automation is the act of scripting or automating a wide variety