Difference between revisions of "Development/General compiler usage"

From bwHPC Wiki
Jump to: navigation, search
m (Makefile structure)
m (Makefile structure)
Line 264: Line 264:
 
* A rule has the form: <br>
 
* A rule has the form: <br>
 
output files: input files<br>
 
output files: input files<br>
<tab><tab>commands to turn inputs to outputs
+
<TAB><TAB>commands to turn inputs to outputs
 
* All commands must be <font color=green>tab-indented</font>.
 
* All commands must be <font color=green>tab-indented</font>.
 
* To reference the variable VAR, surround it with <font color=green>$(VAR)</font>.
 
* To reference the variable VAR, surround it with <font color=green>$(VAR)</font>.
 
* Try running ''''man make'''' for more details.
 
* Try running ''''man make'''' for more details.
  +
<br>
  +
<TAB> = Tabulator
 
<br>
 
<br>
 
<br>
 
<br>

Revision as of 14:38, 18 December 2015

Description Content
module load compiler/gnu|intel|pgi|...
Availability bwUniCluster | BwForCluster_Chemistry | bwGRiD_tu
License Intel: Commercial | GNU: GPL | PGI: Commercial


1 Description

The basic operations can be performed with the same commands for all available compilers. For advanced usage such as optimization and profiling you should consult the best practice guide of the compiler you intend to use (GCC, Intel Suite).

2 Versions and Availability

A list of versions currently available compilers on the bwHPC-C5-Clusters can be obtained from the

Cluster Information System CIS

2.1 GNU

{{#widget:Iframe |url=https://cis-hpc.uni-konstanz.de/prod.cis/bwUniCluster/compiler/gnu |width=99% |height=470 }}

2.2 Intel

{{#widget:Iframe |url=https://cis-hpc.uni-konstanz.de/prod.cis/bwUniCluster/compiler/intel |width=99% |height=430 }}

2.3 PGI

{{#widget:Iframe |url=https://cis-hpc.uni-konstanz.de/prod.cis/bwUniCluster/compiler/pgi |width=99% |height=200 }} On the command line interface of any bwHPC cluster you'll get a list of available versions by using the command
'module avail compiler'.

$ : bwUniCluster
$ module avail compiler
------------------------ /opt/bwhpc/common/modulefiles -------------------------
compiler/gnu/4.5             compiler/intel/12.1
compiler/gnu/4.7(default)    compiler/intel/13.1
compiler/gnu/4.8             compiler/intel/14.0
compiler/gnu/4.9             compiler/intel/15.0(default)
compiler/gnu/5.2
$ : bwForCluster (Justus)
$ module avail compiler
------------------------ /opt/bwhpc/common/modulefiles -------------------------
compiler/gnu/4.5             compiler/intel/15.0(default)
compiler/gnu/4.7(default)    compiler/pgi/12.10(default)
compiler/gnu/4.8             compiler/pgi/12.10_static
compiler/gnu/4.9             compiler/pgi/13.7
compiler/gnu/5.2             compiler/pgi/13.7_static
compiler/intel/12.1          compiler/pgi/14.10
compiler/intel/13.1          compiler/pgi/14.10_static
compiler/intel/14.0


3 Loading the module

3.1 Default Version

You can load the default version of the a compiler with the command
module load compiler/name-of-the-compiler-suite.
Example with Intel on bwUniCluster

$ module avail compiler/intel
------------------------ /opt/bwhpc/common/modulefiles -------------------------
compiler/intel/12.1          compiler/intel/14.0
compiler/intel/13.1          compiler/intel/15.0(default)
$ module load compiler/intel
$ module list
Currently Loaded Modulefiles:
  1) compiler/intel/15.0(default)

Here, we got the "default" version 15.0 (example).
The module will try to load modules it needs to function. If loading the module fails, check if you have already loaded the module with 'module list'.

3.2 Specific (newer or older) Version

If you wish to load a specific compiler version and release (if available), you can do so using
module load compiler/name-of-the-compiler-suite/version-of-the-compiler-suite
to load the version you desires.
Example with Intel compiler, version 14.0 on bwUniCluster

$ module avail compiler/intel
------------------------ /opt/bwhpc/common/modulefiles -------------------------
compiler/intel/12.1          compiler/intel/14.0
compiler/intel/13.1          compiler/intel/15.0(default)
$ module load compiler/intel/14.0
$ module list
Currently Loaded Modulefiles:
  1) compiler/intel/14.0

Intel C-Compiler "version 14.0" is loaded now (example).

All Intel, GCC and PGI have compilers for different languages which will be available after the module is loaded.

3.3 Linux Original Compiler

The original Compiler installed on all compute nodes is GNU.

  • Don't get distracted with the available compiler modules.
  • Only the modules are loading the complete environments needed.

Example

$ module clear                     # unload all modules
Are you sure you want to clear all loaded modules!? [n] y
$ module list                      # control
No Modulefiles Currently Loaded.
$ gcc --version                    # see version of default Linux GNU compiler
gcc (GCC) 4.4.7 20120313 (Red Hat 4.4.7-16)
[...]
$ module load compiler/gnu         # load default GNU compiler module
$ module list                      # control
Currently Loaded Modulefiles:
  1) compiler/gnu/4.7(default)
$ gcc --version                    # now, check the current (loaded) module
gcc (GCC) 4.7.3 
[...]


4 Synoptical Tables

Compiler Suite Language Command
Intel Composer

• Best Practice Guides on Intel Compiler Software
C icc
C++ icpc
Fortran ifort
GCC

• Best Practice Guides on GNU Compiler Software
C gcc
C++ g++
Fortran gfortran
PGI C pgcc
C++ pgCC
Fortran 77/90 pgf77 or pgf90


5 How to use

The following compiler commands work for all the compilers in the list above even though the examples will be for icc only.

5.1 Commands

When hello.c is a C source code file such as

#include <stdio.h>
int main() {
    printf("Hello world\n");
    return 0;
}

it can be compiled and linked with the single command

$ icc hello.c -o hello

to produce an executable named hello.

This process can be divided into two steps:

$ icc -c hello.c
$ icc hello.o -o hello

When using libraries you must sometimes specify where the

  • include files are (option -I) and where the
  • library files are (option -L).

In addition you have to tell the compiler which

  • library you want to use (option -l).

For example after loading the module numlib/fftw you can compile code for fftw using

$ icc -c hello.c -I$FFTW_INC_DIR
$ icc hello.o -o hello -L$FFTW_LIB_DIR -lfftw3

When the program crashes or doesn't produce the expected output the compiler can help you by printing warning messages:

$ icc -Wall hello.c -o hello

5.2 Debugger

If the problem can't be solved this way you can inspect what exactly your program does using a debugger.
To use the debugger properly with your program you have to compile it with debug information (option -g):
Example

$ icc -g hello.c -o hello

Although -Wall should always be set, the -g option should only be stated when you want to find bugs, since it may slow down execution and enlarges the binary due to debugging symbols.

5.3 Optimization

The usual and common way to compile your source is to apply compiler optimization.
Since there are many optimization options, as a start for now the optimization level -O2 is recommended:

$ icc -O2 hello.c -o hello

Beware: The optimization-flag used is a capital-O (like Otto) and not a 0 (Zero)!

Both compilers offer a multitude of options (with regard to the above and others), one may check the complete list of options with short explanation on GCC and Intel Suite using option -v --help:

$ icc -v --help hello.c -o hello


6 Makefile

If you're working in a project that already uses make, there should be a file called Makefile in the top-level directory. Running:

$ make

should build the project from source.

6.1 What is make?

Make is a tool designed to manage dependencies in a build process.
For instance, if you have a source file called hello.c and you need to build the binary/executable hello, then you might have a Makefile in the same directory that looks like this:

 
CC      = icc
CFLAGS  = -g
RM      = rm -f

default: all

all: hello

hello: hello.c
<TAB>$(CC) $(CFLAGS) -o hello hello.c

clean veryclean:
<TAB>$(RM) hello

When ordered to build a file, make will ensure that all dependencies are up to date, and it will not rebuild any those which need not be rebuilt.

6.2 Makefile structure

Makefiles contain definitions and rules.

  • A definition has the form:

VAR=value

  • A rule has the form:

output files: input files
<TAB><TAB>commands to turn inputs to outputs

  • All commands must be tab-indented.
  • To reference the variable VAR, surround it with $(VAR).
  • Try running 'man make' for more details.


<TAB> = Tabulator