Glossary of terms

ancestor tasks

The set of tasks formed by a parent task and all its ancestors.

base language

The base language is the programming language in which the program is written.

child task

A task is another task’s child when the latter encounters its task generating code.

construct

A construct is an executable directive and its associated statement. Unlike the OpenMP terminology, we explicitly refer to the lexical scope of a construct or the dynamic extent of a construct when needed.

data environment

The data environment of a task is formed by its associated set of variables.

declarative directive

A directive that annotates a declarative statement.

dependence

The relationship existing between a predecessor task and one of its successor tasks.

descendant tasks

The descendant tasks of a given task are a set of all its child tasks and their descendants.

directive

In C/C++ a #pragma preprocessor entity.

In Fortran a comment which follows a given syntax.

dynamic extent

A dynamic extent is the interval between establishing an execution entity and its explicit disestablishment. Dynamic extents always obey a stack-like discipline while running the code, and include any code in called routines as well as any implicit code introduced by the OmpSs-2 implementation.

executable directive

A directive that annotates an executable statement.

expression

A combination of one or more data components and operators that the base program language may understand.

function task

In C, a task declared by a task directive at file-scope that comes before a declaration that declares a single function or comes before a function-definition. In both cases the declarator should include a parameter type list.

In C++, a task declared by a task directive at namespace-scope or class-scope that comes before a function-definition or comes before a declaration or member-declaration that declares a single function.

In Fortran, a task declared by a task directive that comes before a the SUBROUTINE statement of an external-subprogram, internal-subprogram or an interface-body.

inline task

In C/C++ an explicit task created by a task directive in a statement inside a function-definition.

In Fortran, an explicit task created by a task directive in the executable part of a program unit.

lexical scope

The lexical scope is the portion of code which is lexically (i.e. textually) contained within the establishing construct including any implicit code lexically introduced by the OmpSs-2 implementation. The lexical scope does not include any code in called routines.

outline tasks

An outlined task is also know as a function task.

predecessor task

A task becomes predecessor of another task when there are dependences between both (i.e. its successor tasks). In other words, there is a restriction in the order the runtime system must execute them: all predecessor tasks must complete before a successor task can be executed.

parent task

A task encountering another task’s generating code is its parent task.

ready task pool

The set of tasks ready to be executed (i.e. they are not blocked by any condition).

structured block

An executable statement with a single entry point (at the top) and a single exit point (at the bottom).

successor task

A task becomes successor of another task when there are dependences between them (i.e. its predecessor task and itself). In other words, there is a restriction in the order the runtime system must execute them: all predecessor tasks must complete before a successor task can be executed.

task

A task is the minimum execution entity that can be managed independently by the runtime scheduler (although a single task may be executed at different phases according to its task scheduling points). Tasks in OmpSs-2 can be created by any task generating code.

task dependency graph

The set of tasks and its relationships (successor / predecessor) with respect to the correspondant scheduling restrictions.

task generating code

The code which creates a new task upon being executed. In OmpSs-2, it can occur when encountering a task construct, a loop construct or when calling a routine annotated with a task declarative directive.

task scheduling point

The different points in which the runtime system may suspend the execution of the current task and execute a different one.