loki.jit_build.compiler module

clean(filename, pattern=None)

Clean up compilation files of previous runs.

Parameters:

  • filename – Filename that triggered the original compilation.

  • suffixes – Optional list of filetype suffixes to delete.

compile(filename, include_dirs=None, compiler=None, cwd=None)
compile_and_load(filename, cwd=None, f90wrap_kind_map=None, compiler=None)

Just-in-time compile Fortran source code and load the respective module or class.

Both paths, classic subroutine-only and modern module-based are supported via the f2py and f90wrap packages.

Parameters:

  • filename (str) – The source file to be compiled.

  • cwd (str, optional) – Working directory to use for calls to compiler.

  • f90wrap_kind_map (str, optional) – Path to f90wrap KIND_MAP file, containing a Python dictionary in f2py_f2cmap format.

  • compiler (Compiler, optional) – Use the specified compiler to compile the Fortran source code. Defaults to _default_compiler

class Compiler

Bases: object

Base class for specifying different compiler toolchains.

CC = None
CFLAGS = None
CPP = None
CPPFLAGS = None
F90 = None
F90FLAGS = None
FC = None
FCFLAGS = None
LD = None
LDFLAGS = None
LD_STATIC = None
LDFLAGS_STATIC = None
compile_args(source, target=None, include_dirs=None, mod_dir=None, mode='f90')

Generate arguments for the build line.

Parameters:

sourcestr or pathlib.Path

Path to the source file to compile

targetstr or pathlib.Path, optional

Path to the output binary to generate

include_dirslist of str or pathlib.Path, optional

Path of include directories to specify during compile

mod_dirstr or pathlib.Path, optional

Path to directory containing Fortran .mod files

modestr, optional

One of 'f90' (free form), 'f' (fixed form) or 'c'

compile(source, target=None, include_dirs=None, use_c=False, use_cpp=False, cwd=None)

Execute a build command for a given source.

linker_args(objs, target, shared=True)

Generate arguments for the linker line.

Execute a link command for a given source.

static f90wrap_args(modname, source, kind_map=None)

Generate arguments for the f90wrap utility invocation line.

f90wrap(modname, source, cwd=None, kind_map=None)

Invoke f90wrap command to create wrappers for a given module.

f2py_args(modname, source, libs=None, lib_dirs=None, incl_dirs=None, cwd=None)

Generate arguments for the f2py-f90wrap utility invocation line.

f2py_env()
f2py(modname, source, libs=None, lib_dirs=None, incl_dirs=None, cwd=None)

Invoke f90wrap command to create wrappers for a given module.

get_compiler_from_env(env=None)

Utility function to determine what compiler to use

This takes the following environment variables in the given order into account to determine the most likely compiler family: F90, FC, CC.

Currently, GNUCompiler and NvidiaCompiler are available.

The compiler binary and flags can be further overwritten by setting the corresponding environment variables:

  • CC, FC, F90, LD for compiler/linker binary name or path

  • CFLAGS, FCFLAGS, LDFLAGS for compiler/linker flags to use

Parameters:

env (dict, optional) – Use the specified environment (default: os.environ)

Returns:

A compiler object

Return type:

Compiler

class GNUCompiler

Bases: Compiler

GNU compiler configuration for gcc and gfortran

CC = 'gcc'
CFLAGS = ['-g', '-fPIC']
CPP = 'g++'
CPPFLAGS = ['-g', '-fPIC']
F90 = 'gfortran'
F90FLAGS = ['-g', '-fPIC']
FC = 'gfortran'
FCFLAGS = ['-g', '-fPIC']
LD = 'gfortran'
LDFLAGS = ['-static']
LD_STATIC = 'ar'
LDFLAGS_STATIC = ['src']
F2PY_FCOMPILER_TYPE = 'gnu95'
CC_PATTERN = re.compile('(^|/|\\\\)gcc\\b')
CPP_PATTERN = re.compile('(^|/|\\\\)g\\+\\+\\b')
FC_PATTERN = re.compile('(^|/|\\\\)gfortran\\b')
class NvidiaCompiler

Bases: Compiler

NVHPC compiler configuration for nvc and nvfortran

CC = 'nvc'
CFLAGS = ['-g', '-fPIC']
CPP = 'nvc++'
CPPFLAGS = ['-g', '-fPIC']
F90 = 'nvfortran'
F90FLAGS = ['-g', '-fPIC']
FC = 'nvfortran'
FCFLAGS = ['-g', '-fPIC']
LD = 'nvfortran'
LDFLAGS = ['-static']
LD_STATIC = 'ar'
LDFLAGS_STATIC = ['src']
F2PY_FCOMPILER_TYPE = 'nv'
CC_PATTERN = re.compile('(^|/|\\\\)nvc\\b')
CPP_PATTERN = re.compile('(^|/|\\\\)nvc\\+\\+\\b')
FC_PATTERN = re.compile('(^|/|\\\\)(pgf9[05]|pgfortran|nvfortran)\\b')