Glossary of terms
=================
.. index:: glossary

.. glossary::

    ancestor tasks
        The set of tasks formed by your *parent* task and all of its *ancestor tasks*.

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

    child task
        A task is a child of the task which encounters its *task generating code*.

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

    data environment
        The *data environment* is formed by the set of variables associated with a given *task*.

    declarative directive
        A directive that annotates a declarative statement.

    dependence
       Is the relationship existing between a *predecessor task* and one of its *successor tasks*.
    
    descendant tasks
       The descendant tasks of a given task is the set of all its child tasks and the descendant tasks of them.
    
    directive
        In C/C++ a *#pragma* preprocessor entity.

        In Fortran a comment which follows a given syntax.

    dynamic extent
        The *dynamic extent* is the interval between establishment of the execution entity and its explicit disestablishment.
        Dynamic extent always obey to a stack-like discipline while running the code and it includes 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
       Is a combination of one or more data components and operators that the base program language may understand.
    
    function task
        In C, an 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 tasks*.

    predecessor task
       A task becomes *predecessor* of another task(s) when there are dependence(s) between this task and the other ones (i.e. its *successor tasks*.
       That is, there is a restriction in the order the run-time system must execute them: all *predecessor tasks* must complete before a *successor task* can be executed.

    parent task
        The task that encountered a *task generating code* is the parent task of the new created task(s).

    ready task pool
        Is 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(s) when there are dependence(s) between these tasks (i.e. its *predecessors tasks*) and itself.
        That is, there is a restriction in the order the run-time system must execute them: all the *predecessor task* must complete before a *successor task* can be executed.

    task
        A task is the minimum execution entity that can be managed independently by the run-time scheduler (although a single task may be executed at different phases according with 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 the correspondant scheduling restrictions.

    task generating code
        The code which execution create a new task.
        In OmpSs-2 it can occurs 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 wich the run-time system may suspend the execution of the current task and execute a different one.