- different approach in pystencils: absolute indexing

- extended pystencils
- Visualization for list LBM
- not yet working

- support aligned load/stores
- nontemporal stores
- aligned memory allocation for arrays and temporary buffers

- vectorization for loops with ranges that are not a multiple of vector width
- vectorization for variable sized loops if special transformation
  replace_inner_stride_with_one is run

- move_constants_before_loop: in the rare case that a symbol
  with same name exists in move target - the assignment is not moved
  previously an exception was raised in this case
- consistent naming of intermediate base pointers

- previously moved only SympyAssignments
- relevant for custom boundary nodes, which are now pulled before loops

- SSA form is checked
- loop independence condition is checked
- bug fix in Field.create_generic when using index_shape

- new kernel creation function for kernels that write to staggered fields
- simplification of conditionals with integers uses ISL library now
  via islpy bindings

- removed warnings
- added flake8 as CI target

- test run again
- notebooks not yet

- assignment collection
- sympyextensions

- Previously sympy.Eq was used to represent assignments. However Eq
  represents equality not assignment. This means that sometimes sympy
  "simplified" an equation like a = a  to True,
-> replaced sp.Eq by pystencils.Assignment everywhere
- renamed EquationCollection to AssignmentCollection

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...

- loop cutting
- simplification of conditionals inside loop

Added LLVM: CodePrinter and a compiler
Updated data_types
Added tests
Added jupyter notebooks
Fixed bugs
Restructured transformation functions

- activated vectorization for LBM kernels

- renaming because of clashes with types.py from other packages

- first vectorization tests are running
- type system: use memoized getTypeOfExpression
- casts are done using sp.Function('cast')
- C backend adapted for vectorization support
- AST nodes can required optional headers

- support for kernels that run over walberla ghost layers

- old method produced unused variables
- old method was not deterministic in the output code i.e. ordering of
  the introduced constants
- moveConstantsBeforeLoops transformation was also not deterministic

-> reading from arrays was slower with some compilers