0.20.7

Added

• Better exploitation of parallelism in fused nested segmented
  reductions.

• Prelude function not for negating booleans.

Fixed

• Some incorrect removal of copies (#1505).

• Handling of parametric modules with top-level existentials (#1510).

• Module substitution fixes (#1512, #1518).

• Invalid in-place lowering (#1523).

• Incorrect code generation for some intra-group parallel code versions.

• Flattening crash in the presence of irregular parallelism (#1525).

• Incorrect substitution of type abbreviations with hidden sizes (#1531).

• Proper handling of NaN in min/max functions for
  f16/f32/f64 in interpreter (#1528).

0.20.6

Added

• Much better code generation for segmented scans with vectorisable
  operators.

Fixed

• Fixes to extremely exotic GPU scans involving array operators.

• Missing alias tracking led to invalid rewrites, causing a compiler
  crash (#1499).

• Top-level bindings with existential sizes were mishandled (#1500, #1501).

• A variety of memory leaks in the multicore backend, mostly (or
  perhaps exclusively) centered around context freeing or failing
  programs - this should not have affected many people.

• Various fixes to f16 handling in the GPU backends.

0.20.5

Added

• Existential sizes can now be explicitly quantified in type
  expressions (#1308).

• Significantly expanded error index.

• Attributes can now be numeric.

• Patterns can now have attributes. None have any effect at the
  moment.

• futhark autotune and futhark bench now take a --spec-file
  option for loading a test specification from another file.

Fixed

• auto output reference datasets are now recreated when the program
  is newer than the data files.

• Exotic hoisting bug (#1490).

0.20.4

Added

• Tuning parameters now (officially) exposed in the C API.

• futhark autotune is now 2-3x faster on many programs, as it now
  keeps the process running.

• Negative numeric literals are now allowed in case patterns.

Fixed

• futhark_context_config_set_profiling was missing for the c backend.

• Correct handling of nested entry points (#1478).

• Incorrect type information recorded when doing in-place lowering (#1481).

0.20.3

Added

• Executables produced by C backends now take a --no-print-result option.

• The C backends now generate a manifest when compiling with
  --library. This can be used by FFI generators (#1465).

• The beginnings of a Rust-style error index.

• scan on newer CUDA devices is now much faster.

Fixed

• Unique opaque types are named properly in entry points.

• The CUDA backend in library mode no longer exit()s the process if
  NVRTC initialisation fails.

0.20.2

Fixed

• Simplification bug (#1455).

• In-place-lowering bug (#1457).

• Another in-place-lowering bug (#1460).

• Don't try to tile inside loops with parameters with variant sizes (#1462).

• Don't consider it an ICE when the user passes invalid command line
  options (#1464).

0.20.1

Added

• The #[trace] and #[break] attributes now replace the trace
  and break functions (although they are still present in
  slightly-reduced but compatible form).

• The #[opaque] attribute replaces the opaque function, which is
  now deprecated.

• Tracing now works in compiled code, albeit with several caveats
  (mainly, it does not work for code running on the GPU).

• New wasm and wasm-multicore backends by Philip Lassen. Still
  very experimental; do not expect API stability.

• New intrinsic type f16, along with a prelude module f16.
  Implemented with hardware support where it is available, and with
  f32-based emulation where it is not.

• Sometimes slightly more informative error message when input of
  the wrong type is passed to a test program.

Changed

• The ! function in the integer modules is now called not.

• ! is now builtin syntax. You can no longer define a function
  called !. It is extremely unlikely this affects you. This
  removes the last special-casing of prefix operators.

• A prefix operator section (i.e. (!)) is no longer permitted
  (and it never was according to the grammar).

• The offset parameter for the "raw" array creation functions in the
  C API is now int64_t instead of int.

Fixed

• i64.abs was wrong for arguments that did not fit in an i32.

• Some f32 operations (**, abs, max) would be done in double
  precision on the CUDA backend.

• Yet another defunctorisation bug (#1397).

• The clz function would sometimes exhibit undefined behaviour in
  CPU code (#1415).

• Operator priority of prefix - was wrong - it is now the same as
  ! (#1419).

• futhark hash is now invariant to source location as well as
  stable across OS/compiler/library versions.

• futhark literate is now much better at avoiding unnecessary
  recalculation.

• Fixed a hole in size type checking that would usually lead to
  compiler crashes (#1435).

• Underscores now allowed in numeric literals in test data (#1440).

• The cuda backend did not use single-pass segmented scans as
  intended. Now it does.

0.19.7

Added

• A new memory reuse optimisation has been added. This results in
  slightly lower footprint for many programs.

• The cuda backend now uses a fast single-pass implementation for
  segmented scans, due to Morten Tychsen Clausen (#1375).

• futhark bench now prints interim results while it is running.

Fixed

• futhark test now provides better error message when asked to
  test an undefined entry point (#1367).

• futhark pkg now detects some nonsensical package paths (#1364).

• FutharkScript now parses f x y as applying f to x and y,
  rather than as f (x y).

• Some internal array utility functions would not be generated if
  entry points exposed both unit arrays and boolean arrays (#1374).

• Nested reductions used (much) more memory for intermediate results
  than strictly needed.

• Size propagation bug in defunctionalisation (#1384).

• In the C FFI, array types used only internally to implement opaque
  types are no longer exposed (#1387).

• futhark bench now copes with test programs that consume their
  input (#1386). This required an extension of the server protocol
  as well.

0.19.6

Added

• f32.hypot and f64.hypot are now much more numerically exact in
  the interpreter.

• Generated code now contains a header with information about the
  version of Futhark used (and maybe more information in the
  future).

• Testing/benchmarking with large input data (including randomly
  generated data) is much faster, as each file is now only read
  once.

• Test programs may now use arbitrary FutharkScript expressions to
  produce test input, in particular expressions that produce opaque
  values. This affects both testing, benchmarking, and autotuning.

• Compilation is about 10% faster, especially for large programs.

Fixed

• futhark repl had trouble with declarations that produced unknown
  sizes (#1347).

• Entry points can now have same name as (undocumented!) compiler intrinsics.

• FutharkScript now detects too many arguments passed to functions.

• Sequentialisation bug (#1350).

• Missing causality check for index sections.

• futhark test now reports mismatches using proper indexes (#1356).

• Missing alias checking in fusion could lead to compiler crash (#1358).

• The absolute value of NaN is no longer infinity in the interpreter (#1359).

• Proper detection of zero strides in compiler (#1360).

• Invalid memory accesses related to internal bookkeeping of bounds checking.

0.19.5

Added

• Initial work on granting programmers more control over existential
  sizes, starting with making type abbreviations function as
  existential quantifiers (#1301).

• FutharkScript now also supports arrays and scientific notation.

• Added f32.epsilon and f64.epsilon for the difference between
  1.0 and the next larger representable number.

• Added f32.hypot and f64.hypot for your hypothenuse needs (#1344).

• Local size bindings in let expressions, e.g:

  let [n] (xs': [n]i32) = filter (>0) xs
  in ...
  

Fixed

• futhark_context_report() now internally calls
  futhark_context_sync() before collecting profiling information
  (if applicable).

• futhark literate: Parse errors for expression directives now
  detected properly.

• futhark autotune now works with the cuda backend (#1312).

• Devious fusion bug (#1322) causing compiler crashes.

• Memory expansion bug for certain complex GPU kernels (#1328).

• Complex expressions in index sections (#1332).

• Handling of sizes in abstract types in the interpreter (#1333).

• Type checking of explicit size requirements in loop parameter (#1324).

• Various alias checking bugs (#1300, #1340).