João Victor Tozatti Risso authored 7 years ago and Martin Bauer committed 7 years ago

Concept: Generate code involving the (un)packing of fields (from)to linear
(1D) arrays, i.e. (de)serialization of the field values for buffered
communication.

A linear index is generated for the buffer, by inferring the strides and
variables of the loops over fields in the AST. In the CPU, this information is
obtained through the makeLoopOverDomain function, in
pystencils/transformations/transformations.py. On CUDA, the strides of
the fields (excluding buffers) are combined with the indexing variables to infer
the indexing of the buffer.

What is supported:
    - code generation for both CPU and GPU
    - (un)packing of fields with all the memory layouts supported by
    pystencils
    - (un)packing slices of fields (from)into the buffer
    - (un)packing subsets of cell values from the fields (from)into the buffer

Limitations:

- assumes that only one buffer and one field are being operated within
each kernel, however multiple equations involving the buffer and the
field are supported.

- (un)packing multiple cell values (from)into the buffer is supported,
however it is limited to the fields with indexDimensions=1. The same
applies to (un)packing subset of cell values of each cell.

Changes in this commit:

- add the FieldType enumeration to pystencils/field.py, to mark fields
of various types. This is replaces and is a generalization of the
isIndexedField boolean flag of the Field class. For now, the types
supported are: generic, indexed and buffer fields.

- add the fieldType property to the Field class, which indicates the
type of the field. Modifications were also performed to the member
functions of the Field class to add this property.

- add resolveBufferAccesses function, which replaces the fields marked
as buffers with the actual field access in the AST traversal.

Miscelaneous changes:

- add blockDim and gridDim variables as CUDA indexing variables.

Fixed demo_heat_equation notebook.

Fixed toDot.

Remove unnecessary comments.

because boundary handling does its own flag management

- sphinx detection is not reliable, e.g. jupyter notebooks have sphinx
  imported at startup -> no caching from notebooks
- explicitly added cached functions via autofunction to docs
- some functions do not support memory cache, because memory cache can't
  handle non-hashable parameters -> introduced diskcacheNoFallback
  decorator for these functions

- single function to create kernel for specified target
- data type creation from string - reuse numpy functionality
- bugfixes in dot display

Added DebugGui

- loop cutting
- simplification of conditionals inside loop

- alignment of index array when using additional data
- data types have been hashed incorrectly

Updated testing of kerncraft_coupling and some functions in
kerncraft_coupling in order to be compatible with the kerncraft version 5.1

Testcases test_mu_equivalence, test_phi_equivalence are passing.

- support for logical operators, and/or
- both phase field kernels can be vectorized now

- phasefield phi sweep vectorizes successfully