Commit 8499cc9f authored by Christian Godenschwager's avatar Christian Godenschwager
Browse files

Add README.md

parent 296b2eee
# Last Exercise
## Compiler
### Run the Compiler:
```bash
g++ <options> <source_file_name>
```
If you did not specify the `-o` option (see below) the compiler will produce an output file named `a.out`.
### Compiler Options
Some compile options that might be useful:
- `-o <filename>` sets the output filename for your executable
- `-Wall` enables all warnings
- `-Wextra` enables even more warnings than all warnings :astonished:
- `-pedantic` disables all compiler vendor specific language extensions so your program must be in conformance with the international standard
- `-O3` enables most optimizations
- `march=native` optimize for the hardware architecture you are compiling on
- `-std=c++14` sets the compiler to behave according to the C++14 international standard
- `-fsanitize=address` enables that address sanitizer which detects memory leaks and other problems at runtime
## Program Structure
### Main Function
You `.cpp` file requires a `main` function which specifies what your program does if you execute it:
```c++
int main( int argc, char * argv[] )
{
}
```
Any returned value will be the return code of your program. If no value is returned it will be zero. The arguments can be omitted if no command line arguments are required.
I recommend transforming the arguments to a `std::vector<std::string>`:
```c++
std::vector<std::string> args( argv, argv + argc );
```
Note that the first argument is always the executable name!
### Source and Header Files
Declarations go to header files (`.h`) , definitions go to source (`.cpp`) files. For function and class templates both, declarations and definitions have to go to header files, since they are only instantiated at the time they are used.
If functions should be able to be _inlined_ for performance reasons, their definition also has to go to the header file and the function has to be declared `inline`.
#### Header Files
Each header file must start with a `#pragma once` preprocessor instruction to avoid double inclusion and redefinition errors.
## CMake
To generate Makefiles use CMake. A project using CMake needs a `CMakeLists.txt` in its root directory. An example can be found in the `CMakeDemo` directory.
### Generating Build Files
It is advised that build files are generated in a separate directory from the source files (called an out-of-source build). To do this create a `build` directory or use the empty provided in this repository. Then run CMake:
```bash
cmake <path_to_src_dir>
```
CMake will create the necessary Makefiles for you in your `build` directory.
### Build your Project
To build the complete project run
```bash
make
```
To build only a single executable run
```bash
make <executable_name>
```
You can get rid of the build object files and executables using
```bash
make clean
```
### CMake Project Options
To edit your CMake project options run (inside your `build` directory:
```bash
ccmake .
```
Most importantly you can set the build type to `Debug` or `Release` where the latter activates compiler optimizations and removes debug symbols from your program.
In the demo project there is also a `SANITIZE_ADDRESS` option which enables the address sanitizer.
You can see more options if you hit `t` while in `ccmake`. Then you can also set additional `CMAKE_CXX_FLAGS`, meaning compiler options.
## Some Things you could do:
### Sanitize Your Matrix Class
Take your matrix classes using dynamic memory allocation with or without the `std::unique_ptr` and add a program which copies, moves and destroys your matrix class. Enable the address sanitizer and see if there are any issues with your code! Try to add your test program(s) as new CMake executable(s).
### Performance Measurements STL
Time some of the STL algorithms and containers we used in exercise. Compare different compiler options. A class timer is already in the CMakeDemo directory. Try to add your benchmark(s) as new CMake executable(s).
### Optimize Matrix Multiplication
There is already a `matmult` application in the CMake directory which measures the runtime of the matrix multiplication. The naive implementation performs rather poorly, try to change that! As a first step you could try to transpose the second matrix, so that you have line-wise access to both matrices during the algorithm. Secondly you could try to implement a blocking strategy (https://en.wikipedia.org/wiki/Loop_nest_optimization) to improve locality and cache reuse.
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment