Compiler flags

[everythingfunctional]

How should we organize/specify compiler flags?

Should we only have two sets of compiler flags? devel-options and release-options, and they are used to build all dependencies and executables?

Also, should we come up with our own keywords for specifying the compiler options, and have a look up table to determine the correct flag for each compiler?

[certik]

We will have to iterate on this, I don't know all the details either yet. Here are some guiding principles:

• We should have Debug and Release builds. (I would call it Debug, not Devel.)
• Perhaps also ReleaseCheck (that would enable all optimizations, but keep all runtime checks; it could be named differently, perhaps ReleaseSafe, or something).

The Debug build should enable all runtime and compile time checks / warnings that a given compiler allows. The Release build should make the fastest build for the given architecture. For ifort I think that's the default (i.e. no options). For gfortran that's -O3 -march=native -ffast-math -funroll-loops (the later gfortran versions also have -Ofast which does a lot of these and a few more --- so we should look into it and probably use it).

So as a start, I would start with Debug and Release. Then as we go, we can keep refining it.

We can take the initial options for gfortran / Intel from here:

https://www.fortran90.org/src/faq.html#what-compiler-options-should-i-use-for-development
https://www.fortran90.org/src/faq.html#what-compiler-options-should-i-use-for-production-run

[everythingfunctional]

Those are good suggestions for defaults. But I'm more talking about what we want to allow users to specify.

Should we only allow users to specify a single set of compiler flags for each of debug and release modes? Or should there be some more granularity available? Different flags for executables vs libraries?

Also, when a user specifies compiler flags manually, should they specify the flags directly (i.e. "-funroll-loops") or with a more generic option that looks up the specific flag for the given compiler?

[certik]

Ah I see. I would definitely allow to specify any compiler flag to any file and any executable / library. That way it should be possible to build any project out there. It's just that we want to discourage users doing that obviously, but we should allow that.

Regarding "generic options" like "unroll loops" for "-funroll-loops`, I would not do that, because I think it will be very hard to find such options for every compiler. Initially the only generic options that I would allow are Debug / Release / ReleaseSafe. Later on, we can perhaps add more, if users request them.

So for example, the user can select Debug mode that would be applied to every file, except those that the user specifically sets manually.

[everythingfunctional]

Ok, that's definitely going to have to take some thinking about how to design on both the fpm.toml side, and the actual build process side.

[certik]

We should not over design this. Right now we are just writing a prototype, to help us figure out the requirements, because what you are asking for are the requirements which we do not know yet, until we gain more experience using fpm with actual Fortran codebases.

[everythingfunctional]

You're right. I'm just going to leave out the options to specify compiler flags for now. Until we have time to design it properly.

[ivan-pi]

What I personally understand as a debug build is enabling (some of) the following options:

• Generate debugging information (should be used with a lower optimization level)
  • gfortran -g (use with -O0 or -Og)
  • ifort (Linux, macOS): -g[n], -debug
  • ifort (Windows) /Zi, /Z7
  • NAG -g
• Enable backtrace of runtime errors
  • gfortran -fbacktrace
  • ifort -traceback
  • NAG -gline
• Run-time checks
  • gfortran -fcheck=[all,array-temps,bits,bounds,do,mem,pointer,recursion]
  • ifort -check=[arg_temp_created,assume,bounds,contiguous,format,output_conversion,pointers,shape,stack,udio_iostat,uninit,all]
  • NAG -C, -C=[alias,all,array,bits,calls,dangling,do,intovf,none,present,pointer,recursion,undefined]

Additionally, we could set flags related to handling floating-point exceptions as provided here (Intel) and here (gfortran).