- New FSCL language. Collection functions can be used of any order. Collection functions of lowest order are translated into OpenCL kernels, the ones of higher orders encodes multi-thread coordination of (sub)kernels. Kernel-FlowGraph creation inside the compiler (previously was built from within the FSCL.Runtime). Double precision correctly handled generating appropriate OpenCL directives
- Bug fix in parsing compositions
- Support for F# two-components tuple
- Big fix for on-the-fly anonymous structs and options
- Added tests to validate various possibilities of declaring an utility function (static/instance method, lambda, field)
- Added tests to validate various possibilities of declaring a kernel (static/instance method, lambda, field)
- Enabled class fields to represent code-time or opencl-compile-time macros
- Bug ix in parsing static and instance methods
- Handling parsing of closures derived from slicing and using class members
- For Array.reduce and Array.sum the output array in kernel is forced not to be transferred back to the host. This fixes a bug that causes the final value computed on the CPU
to be overwritten by the content of the (first item of the) output array when transferred back to the host
- Referencing let-variables or properties declared outside kernels turn into -define- macros only if ReflectedDefinitionAttribute is associated to the variable/property
- No need to use DynamicDefine attribute anymore. Immutable variables/propeties are replaced with the corresponding value (expression) when OpenCL source code is generated. OpenCL-target-code-generation-time defines are generated (by the runtime) for mutable variables/properties
- Automatic characterization of lambda functions (if a lambda has a WorkItemInfo param it's turn into a kernel, otherwise it's applied by reflection on the CPU)
- Optimisation of parsing step to speed up the runtime. Approximatively 80 microsecs on macbook pro i5.
- Bug fix
- Added support for pipelining operators (|>, ||> and |||>)
- Added support for partial functions (curried form)
- Added support for lambda application
- Fixed flattening of multi-dimensional arrays
- Added inline attribute for utility functions. Lambdas are inlined by default
- Fixed reduce code generation to handle records and structs
- Fixed conflict between new struct creation construct (NewObject()) and vectorised data-types
- Enabled utility functions chain calls of arbitrary length (utility functions can call other utility functions)
- Enabled passing arrays to utility functions
- Inserted kernel/function declaration before definition
- Added some tests
- Fixed bug in struct type codegen
- Fixed bug and extended support for structs and records. Now you can use both custom F# records and structs (and arrays of records and structs) as parameters of kernels and functions. Also, you can declare private/local structs and records using record initialisation construct, struct parameterless constructor and "special" struct constructor (a constructor taking N arguments, each of one matching one of the N fields, in the order).
- Valid record decl: let myRec = { field1 = val1; ... fieldN = valN }
- Valid default struct decl: let myStruct = new MyStruct()
- Valid "special constructor" struct decl: let myStruct = new MyStruct(valForField1, valForField2, ... valForFieldN)
- NOT valid struct decl: let myStruct = new MyStruct()
- Fixed bug in char and uchar types handling in codegen
- Restructured project according to F# Project Scaffold
- Iterative reduction execution on CPU
- Work size specification as part of kernel signature
