pyccel.ast.parallel package

Submodules

pyccel.ast.parallel.basic module

class pyccel.ast.parallel.basic.Basic

Bases: sympy.core.basic.Basic

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

dtype(attr)

Returns the datatype of a given attribut/member.

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

pyccel.ast.parallel.communicator module

class pyccel.ast.parallel.communicator.Communicator

Bases: pyccel.ast.parallel.basic.Basic

Represents a communicator in the code.

size: int

the number of processes in the group associated with the communicator

rank: int

the rank of the calling process within the group associated with the communicator

Examples

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

duplicate()

This routine creates a duplicate of the communicator other has the same fixed attributes as the communicator.

Examples

group

the group associated with the communicator.

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

rank

size

split(group)

Split the communicator over colors by returning the new comm associated to the processes with defined color.

Examples

class pyccel.ast.parallel.communicator.UniversalCommunicator

Bases: pyccel.ast.parallel.basic.Basic

Represents the communicator to all processes.

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

group

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

size

pyccel.ast.parallel.communicator.split(comm, group, rank=None)

Splits the communicator over a given color.

Examples

pyccel.ast.parallel.group module

class pyccel.ast.parallel.group.Difference

Bases: sympy.sets.sets.Complement

Represents the difference between two groups.

Examples

>>> from pyccel.ast.parallel.group import Group, Difference
>>> g1 = Group(1, 3, 6, 7, 8, 9)
>>> g2 = Group(0, 2, 4, 5, 8, 9)
>>> Difference(g1, g2)
{1, 3, 6, 7}

default_assumptions = {}

class pyccel.ast.parallel.group.Group

Bases: sympy.sets.sets.FiniteSet

Represents a group of processes.

processes: Set

set of the processes within the group

rank: int

the rank of the calling process within the group

Examples

>>> from pyccel.ast.parallel.group import Group
>>> g = Group(1, 2, 3, 4)
>>> g
{1, 2, 3, 4}
>>> g.size
4

communicator

compare(other)

This routine returns the relationship between self and other If self and other contain the same processes, ranked the same way, this routine returns MPI_IDENT If self and other contain the same processes, but ranked differently, this routine returns MPI_SIMILAR Otherwise this routine returns MPI_UNEQUAL.

default_assumptions = {}

difference(other)

Returns in newgroup all processes in self that are not in other, ordered as in self.

Examples

As a shortcut it is possible to use the ‘-‘ operator:

>>> from pyccel.ast.parallel.group import Group
>>> g1 = Group(1, 3, 6, 7, 8, 9)
>>> g2 = Group(0, 2, 4, 5, 8, 9)
>>> g1.difference(g2)
{1, 3, 6, 7}
>>> g1 - g2
{1, 3, 6, 7}

intersection(other)

Returns in newgroup all processes that are in both groups, ordered as in self.

Examples

>>> from pyccel.ast.parallel.group import Group
>>> g1 = Group(1, 3, 6, 7, 8, 9)
>>> g2 = Group(0, 2, 4, 5, 8, 9)
>>> g1.intersection(g2)
{8, 9}

processes

Returns the set of the group processes.

rank

set_communicator(comm)

size

the number of processes in the group.

translate(rank1, other, rank2)

This routine takes an array of n ranks (ranks1) which are ranks of processes in self. It returns in ranks2 the corresponding ranks of the processes as they are in other. MPI_UNDEFINED is returned for processes not in other

union(other)

Returns in newgroup a group consisting of all processes in self followed by all processes in other, with no duplication.

Examples

As a shortcut it is possible to use the ‘+’ operator:

>>> from pyccel.ast.parallel.group import Group
>>> g1 = Group(1, 3, 6, 7, 8, 9)
>>> g2 = Group(0, 2, 4, 5, 8, 9)
>>> g1.union(g2)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> g1 + g2
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

class pyccel.ast.parallel.group.Intersection

Bases: sympy.sets.sets.Intersection

Represents the intersection of groups.

Examples

>>> from pyccel.ast.parallel.group import Group, Intersection
>>> g1 = Group(1, 3, 6, 7, 8, 9)
>>> g2 = Group(0, 2, 4, 5, 8, 9)
>>> Intersection(g1, g2)
{8, 9}

default_assumptions = {}

class pyccel.ast.parallel.group.Range

Bases: sympy.sets.fancysets.Range

Representes a range of processes.

Examples

>>> from pyccel.ast.parallel.group import Range
>>> from sympy import Symbol
>>> n = Symbol('n')
>>> Range(0, n)
Range(0, n)

default_assumptions = {}

class pyccel.ast.parallel.group.Split

Bases: pyccel.ast.parallel.group.Group

Splits the group over a given color.

Examples

>>> from pyccel.ast.parallel.group import UniversalGroup
>>> from pyccel.ast.parallel.communicator import UniversalCommunicator, split
>>> colors = [1, 1, 0, 1, 0, 0]
>>> g = Split(UniversalGroup(), colors, 0)
>>> g
{2, 4, 5}
>>> comm = split(UniversalCommunicator(), g)
Communicator({2, 4, 5}, None)

default_assumptions = {}

class pyccel.ast.parallel.group.Union

Bases: sympy.sets.sets.Union

Represents the union of groups.

Examples

>>> from pyccel.ast.parallel.group import Group, Union
>>> g1 = Group(1, 3, 6, 7, 8, 9)
>>> g2 = Group(0, 2, 4, 5, 8, 9)
>>> Union(g1, g2)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

default_assumptions = {}

class pyccel.ast.parallel.group.UniversalGroup

Bases: sympy.sets.fancysets.Naturals

Represents the group of all processes. Since the number of processes is only known at the run-time and the universal group is assumed to contain all processes, it is convinient to consider it as the set of all possible processes which is nothing else than the set of Natural numbers.

np: Symbol

a sympy symbol describing the total number of processes.

communicator

default_assumptions = {}

np = np

processes

size

the total number of processes.

pyccel.ast.parallel.mpi module

class pyccel.ast.parallel.mpi.MPI

Bases: pyccel.ast.parallel.basic.Basic

Base class for MPI.

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

pyccel.ast.parallel.mpi.mpify(stmt, **options)

Converts some statements to MPI statments.

stmt: stmt, list

statement or a list of statements

pyccel.ast.parallel.openacc module

class pyccel.ast.parallel.openacc.ACC

Bases: pyccel.ast.parallel.basic.Basic

Base class for OpenACC.

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

class pyccel.ast.parallel.openacc.ACC_Async

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Async
>>> ACC_Async('x', 'y')
async(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'async'

variables

class pyccel.ast.parallel.openacc.ACC_Auto

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Auto
>>> ACC_Auto()
auto

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'auto'

class pyccel.ast.parallel.openacc.ACC_Bind

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Bind
>>> ACC_Bind('n')
bind(n)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'bind'

variable

class pyccel.ast.parallel.openacc.ACC_Collapse

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Collapse
>>> ACC_Collapse(2)
collapse(2)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

n_loops

name = 'collapse'

class pyccel.ast.parallel.openacc.ACC_Copy

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Copy
>>> ACC_Copy('x', 'y')
copy(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'copy'

variables

class pyccel.ast.parallel.openacc.ACC_Copyin

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Copyin
>>> ACC_Copyin('x', 'y')
copyin(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'copyin'

variables

class pyccel.ast.parallel.openacc.ACC_Copyout

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Copyout
>>> ACC_Copyout('x', 'y')
copyout(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'copyout'

variables

class pyccel.ast.parallel.openacc.ACC_Create

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Create
>>> ACC_Create('x', 'y')
create(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'create'

variables

class pyccel.ast.parallel.openacc.ACC_Default

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Default
>>> ACC_Default('present')
default(present)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = None

status

class pyccel.ast.parallel.openacc.ACC_DefaultAsync

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_DefaultAsync
>>> ACC_DefaultAsync('x', 'y')
default_async(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'default_async'

variables

class pyccel.ast.parallel.openacc.ACC_Delete

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Delete
>>> ACC_Delete('x', 'y')
delete(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'delete'

variables

class pyccel.ast.parallel.openacc.ACC_Device

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Device
>>> ACC_Device('x', 'y')
device(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'device'

variables

class pyccel.ast.parallel.openacc.ACC_DeviceNum

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_DeviceNum
>>> ACC_DeviceNum(2)
device_num(2)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

n_device

name = 'device_num'

class pyccel.ast.parallel.openacc.ACC_DevicePtr

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_DevicePtr
>>> ACC_DevicePtr('x', 'y')
deviceptr(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'deviceptr'

variables

class pyccel.ast.parallel.openacc.ACC_DeviceResident

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_DeviceResident
>>> ACC_DeviceResident('x', 'y')
device_resident(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'device_resident'

variables

class pyccel.ast.parallel.openacc.ACC_DeviceType

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_DeviceType
>>> ACC_DeviceType('x', 'y')
device_type(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'device_type'

variables

class pyccel.ast.parallel.openacc.ACC_Finalize

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Finalize
>>> ACC_Finalize()
finalize

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'finalize'

class pyccel.ast.parallel.openacc.ACC_FirstPrivate

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_FirstPrivate
>>> ACC_FirstPrivate('x', 'y')
firstprivate(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'firstprivate'

variables

class pyccel.ast.parallel.openacc.ACC_For

Bases: pyccel.ast.core.ForIterator, pyccel.ast.parallel.openacc.ACC

ACC Loop construct statement.

Examples

body

clauses

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

iterable

loop

name = 'do'

target

class pyccel.ast.parallel.openacc.ACC_Gang

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Gang
>>> ACC_Gang('x', 'y')
gang(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'gang'

variables

class pyccel.ast.parallel.openacc.ACC_Host

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Host
>>> ACC_Host('x', 'y')
host(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'host'

variables

class pyccel.ast.parallel.openacc.ACC_If

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_If
>>> ACC_If(True)
if (True)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'if'

test

class pyccel.ast.parallel.openacc.ACC_IfPresent

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_IfPresent
>>> ACC_IfPresent()
if_present

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'if_present'

class pyccel.ast.parallel.openacc.ACC_Independent

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Independent
>>> ACC_Independent()
independent

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'independent'

class pyccel.ast.parallel.openacc.ACC_Link

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Link
>>> ACC_Link('x', 'y')
link(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'link'

variables

class pyccel.ast.parallel.openacc.ACC_NoHost

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_NoHost
>>> ACC_NoHost()
nohost

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'nohost'

class pyccel.ast.parallel.openacc.ACC_NumGangs

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_NumGangs
>>> ACC_NumGangs(2)
num_gangs(2)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

n_gang

name = 'num_gangs'

class pyccel.ast.parallel.openacc.ACC_NumWorkers

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_NumWorkers
>>> ACC_NumWorkers(2)
num_workers(2)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

n_worker

name = 'num_workers'

class pyccel.ast.parallel.openacc.ACC_Parallel

Bases: pyccel.ast.core.ParallelBlock, pyccel.ast.parallel.openacc.ACC

ACC Parallel construct statement.

Examples

>>> from pyccel.parallel.openacc import ACC_Parallel
>>> from pyccel.parallel.openacc import ACC_NumThread
>>> from pyccel.parallel.openacc import ACC_Default
>>> from pyccel.ast.core import Variable, Assign, Block
>>> n = Variable('int', 'n')
>>> x = Variable('int', 'x')
>>> body = [Assign(x,2.*n + 1.), Assign(n, n + 1)]
>>> variables = [x,n]
>>> clauses = [ACC_NumThread(4), ACC_Default('shared')]
>>> ACC_Parallel(clauses, variables, body)
#pragma parallel num_threads(4) default(shared)
x := 1.0 + 2.0*n
n := 1 + n

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'parallel'

class pyccel.ast.parallel.openacc.ACC_Present

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Present
>>> ACC_Present('x', 'y')
present(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'present'

variables

class pyccel.ast.parallel.openacc.ACC_Private

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Private
>>> ACC_Private('x', 'y')
private(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'private'

variables

class pyccel.ast.parallel.openacc.ACC_Reduction

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Reduction
>>> ACC_Reduction('+', 'x', 'y')
reduction('+': (x, y))

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'reduction'

operation

variables

class pyccel.ast.parallel.openacc.ACC_Self

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Self
>>> ACC_Self('x', 'y')
self(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'self'

variables

class pyccel.ast.parallel.openacc.ACC_Seq

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Seq
>>> ACC_Seq()
seq

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'seq'

class pyccel.ast.parallel.openacc.ACC_Tile

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Tile
>>> ACC_Tile('x', 'y')
tile(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'tile'

variables

class pyccel.ast.parallel.openacc.ACC_UseDevice

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_UseDevice
>>> ACC_UseDevice('x', 'y')
use_device(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'use_device'

variables

class pyccel.ast.parallel.openacc.ACC_Vector

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Vector
>>> ACC_Vector('x', 'y')
vector(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'vector'

variables

class pyccel.ast.parallel.openacc.ACC_VectorLength

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_VectorLength
>>> ACC_VectorLength(2)
vector_length(2)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

n

name = 'vector_length'

class pyccel.ast.parallel.openacc.ACC_Wait

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Wait
>>> ACC_Wait('x', 'y')
wait(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'wait'

variables

class pyccel.ast.parallel.openacc.ACC_Worker

Bases: pyccel.ast.parallel.openacc.ACC

Examples

>>> from pyccel.parallel.openacc import ACC_Worker
>>> ACC_Worker('x', 'y')
worker(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'worker'

variables

pyccel.ast.parallel.openacc.accfy(stmt, **options)

Converts some statements to OpenACC statments.

stmt: stmt, list

statement or a list of statements

pyccel.ast.parallel.openacc.get_for_clauses(expr)

pyccel.ast.parallel.openacc.get_with_clauses(expr)

pyccel.ast.parallel.openmp module

class pyccel.ast.parallel.openmp.OMP

Bases: pyccel.ast.parallel.basic.Basic

Base class for OpenMP.

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

class pyccel.ast.parallel.openmp.OMP_Collapse

Bases: pyccel.ast.parallel.openmp.OMP

OMP CollapseClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_Collapse
>>> OMP_Collapse(2)
collapse(2)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

n_loops

name = 'collapse'

class pyccel.ast.parallel.openmp.OMP_Copyin

Bases: pyccel.ast.parallel.openmp.OMP

OMP CopyinClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_Copyin
>>> OMP_Copyin('x', 'y')
copyin(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'copyin'

variables

class pyccel.ast.parallel.openmp.OMP_Default

Bases: pyccel.ast.parallel.openmp.OMP

OMP ParallelDefaultClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_Default
>>> OMP_Default('shared')
default(shared)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = None

status

class pyccel.ast.parallel.openmp.OMP_FirstPrivate

Bases: pyccel.ast.parallel.openmp.OMP

OMP FirstPrivateClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_FirstPrivate
>>> OMP_FirstPrivate('x', 'y')
firstprivate(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'firstprivate'

variables

class pyccel.ast.parallel.openmp.OMP_For

Bases: pyccel.ast.core.ForIterator, pyccel.ast.parallel.openmp.OMP

OMP Parallel For construct statement.

Examples

body

clauses

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

iterable

loop

name = 'do'

nowait

target

class pyccel.ast.parallel.openmp.OMP_If

Bases: pyccel.ast.parallel.openmp.OMP

OMP ParallelIfClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_If
>>> OMP_If(True)
if (True)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'if'

test

class pyccel.ast.parallel.openmp.OMP_LastPrivate

Bases: pyccel.ast.parallel.openmp.OMP

OMP LastPrivateClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_LastPrivate
>>> OMP_LastPrivate('x', 'y')
lastprivate(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'lastprivate'

variables

class pyccel.ast.parallel.openmp.OMP_Linear

Bases: pyccel.ast.parallel.openmp.OMP

OMP LinearClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_Linear
>>> OMP_Linear('x', 'y', 2)
linear((x, y): 2)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'linear'

step

variables

class pyccel.ast.parallel.openmp.OMP_NumThread

Bases: pyccel.ast.parallel.openmp.OMP

OMP ParallelNumThreadClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_NumThread
>>> OMP_NumThread(4)
num_threads(4)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'num_threads'

num_threads

class pyccel.ast.parallel.openmp.OMP_Ordered

Bases: pyccel.ast.parallel.openmp.OMP

OMP OrderedClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_Ordered
>>> OMP_Ordered(2)
ordered(2)
>>> OMP_Ordered()
ordered

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

n_loops

name = 'ordered'

class pyccel.ast.parallel.openmp.OMP_Parallel

Bases: pyccel.ast.core.ParallelBlock, pyccel.ast.parallel.openmp.OMP

OMP Parallel construct statement.

Examples

>>> from pyccel.parallel.openmp import OMP_Parallel
>>> from pyccel.parallel.openmp import OMP_NumThread
>>> from pyccel.parallel.openmp import OMP_Default
>>> from pyccel.ast.core import Variable, Assign, Block
>>> n = Variable('int', 'n')
>>> x = Variable('int', 'x')
>>> body = [Assign(x,2.*n + 1.), Assign(n, n + 1)]
>>> variables = [x,n]
>>> clauses = [OMP_NumThread(4), OMP_Default('shared')]
>>> OMP_Parallel(clauses, variables, body)
#pragma parallel num_threads(4) default(shared)
x := 1.0 + 2.0*n
n := 1 + n

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'parallel'

class pyccel.ast.parallel.openmp.OMP_Private

Bases: pyccel.ast.parallel.openmp.OMP

OMP PrivateClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_Private
>>> OMP_Private('x', 'y')
private(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'private'

variables

class pyccel.ast.parallel.openmp.OMP_ProcBind

Bases: pyccel.ast.parallel.openmp.OMP

OMP ParallelProcBindClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_ProcBind
>>> OMP_ProcBind('master')
proc_bind(master)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'proc_bind'

status

class pyccel.ast.parallel.openmp.OMP_Reduction

Bases: pyccel.ast.parallel.openmp.OMP

OMP ReductionClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_Reduction
>>> OMP_Reduction('+', 'x', 'y')
reduction('+': (x, y))

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'reduction'

operation

variables

class pyccel.ast.parallel.openmp.OMP_Schedule

Bases: pyccel.ast.parallel.openmp.OMP

OMP ScheduleClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_Schedule
>>> OMP_Schedule('static', 2)
schedule(static, 2)

chunk_size

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

kind

name = 'schedule'

class pyccel.ast.parallel.openmp.OMP_Shared

Bases: pyccel.ast.parallel.openmp.OMP

OMP SharedClause statement.

Examples

>>> from pyccel.parallel.openmp import OMP_Shared
>>> OMP_Shared('x', 'y')
shared(x, y)

default_assumptions = {'composite': False, 'even': False, 'integer': False, 'odd': False, 'prime': False, 'zero': False}

is_composite = False

is_even = False

is_integer = False

is_odd = False

is_prime = False

is_zero = False

name = 'shared'

variables

pyccel.ast.parallel.openmp.get_for_clauses(expr)

pyccel.ast.parallel.openmp.get_with_clauses(expr)

pyccel.ast.parallel.openmp.ompfy(stmt, **options)

Converts some statements to OpenMP statments.

stmt: stmt, list

statement or a list of statements

Module contents