Softpedia >Windows >Programming >Coding languages / Compilers >Poly/ML >  Changelog

Poly/ML Changelog

What's new in Poly/ML 5.9

Feb 10, 2022
  • Native code-generator for ARM/64:
  • There is now a native code-generator for the 64-bit ARM architecture. All features of Poly/ML are supported, including FFI and compact-32 bits. It has been tested on a variety of platforms and operating systems including Mac M1, Windows and WSL as well as the Raspberry Pi on Raspbian and even big-endian NetBSD. At the moment the code-generator does no optimisation so the performance should improve in future releases.
  • Position-independent code for X86/64 and ARM64
  • The code segments in object files created by PolyML.export for X86/64 and ARM64 are now position-independent on Linux and Mac/OS. This is necessary for some platforms and desirable on others. Text relocations are still generated on the X86/32 since changing this would require changes to the code-generator.
  • New bootstrap process
  • The initial build process has been changed to reduce the number of pre-built compilers required. The build process takes longer than before but the final code will be the same.
  • Minor Changes:
  • Additional FFI conversions for size_t, ssize_t, long long, unsigned long long, ptrdiff_t, intptr_t and uintptr_t.
  • Fix to build problem for 5.8.2 on big-endian.
  • Fix to underlying sleep function that could fail in BSD.
  • Fixes for some problems in Unix.execute and Unix.executeInEnv introduced in the changes in 5.8.2.
  • Fixes for Foreign.LowLevel.cTypeUint and cTypeULong which were incorrectly signed rather than unsigned.
  • Fix for systems where PTHREAD_STACK_MIN is a function rather than a constant.
  • Fixes to profiling of live data.
  • Fixed printing of type functions when the type is passed as an argument to a functor.
  • Fix to passing struct argument in SysV x86/64.

New in Poly/ML 5.8.2 (Aug 9, 2021)

  • Major Changes:
  • This release includes a major change to the foreign-function interface (FFI). libffi is no longer used except in the interpreted version and instead interface functions are compiled when the buildXX function is called. This results FFI calls being very much faster. Generally the high-level interface in the Foreign structure is unchanged but the low-level structures are different. Foreign.LibFFI has been removed and there are some changes to the Foreign.LowLevel structure. The buildCallback functions have been replaced with buildClosure functions with a slightly different type. Closures are now garbage-collected so if a closure is created and registered with a foreign module a reference must be retained within ML. For backwards compatibility buildClosure functions have been retained which are not garbage-collected.
  • Minor Changes:
  • Support for IPv6 through the addition of INet6Sock and Net6HostDB structures.
  • Addition of PackReal32Big and PackReal32Little structures.
  • Addition of gcState field to PolyML.Statistics. When statistics are exported this allows another process to monitor garbage-collection. This is not useful for local statistics because the local process cannot read the statistics while garbage-collecting.
  • The word arguments in Foreign.Memory.++, -- and the various get and set operations are now treated as signed values.
  • Added Foreign.loadLibraryIndirect. This calls a function before a library is loaded to obtain the name at that point rather than when using the name bound in when the foreign function call is compiled.
  • .sig is now included in the list of extensions for use and PolyML.make. It is the first choice when looking up a signature in PolyML.make, allowing the same name to be used for a signature and a structure or functor.
  • Unix.execute and Unix.executeInEnv are now implemented in the run-time system rather than in ML using Posix.Process.fork and Posix.Process.exec. fork is problematic because there is the chance that the new process may have to garbage-collect before calling exec.
  • Changes to memory allocation to support executable code areas on platforms such as OpenBSD that do not allow pages to mapped with both execute and write permissions.
  • Improvements to speed up the interpreted byte code version.
  • PolyML.export no longer exports interpreted code as executable since it is not actually executed.
  • When exporting to ELF byte data is written to the .rodata section and relocatable data to .data.rel.ro.
  • Internal changes to Posix.Process.sleep, OS.IO.poll and Socket.select to avoid arbitrary precision arithmetic in the run-time system.
  • Internal change to the Windows structure to implement it largely using FFI.
  • Various internal changes to the interface between the run-time system and the basis library.
  • Internal change to profiling to reduce the effect of profiling on the running program.
  • Bug fixes:
  • Fix exponential blow-up of the compilation in the optimiser/simplifier.
  • Fix Bad Address problem with PolyML.objSize in compact 32-bit version.
  • Fix InternalError exception when compiling a signature with an invalid type realisation.

New in Poly/ML 5.8 (Mar 12, 2019)

  • Major Changes:
  • Option to create a version that supports 32-bit values for the X86/64 platform with a heap size of up to 16Gbytes.
  • Minor Changes:
  • Addition of Real32 structure for 32-bit floating point values.
  • Improved code-generation of booleans and conditionals.
  • Additional statistics via PolyML.Statistics.getLocal/Remotestatistics.
  • Changes and speed-ups to IO and Networking.
  • Avoids mutex lock at the start of run-time calls which resulted in contention in arbitrary precision arithmetic.

New in Poly/ML 5.7.1 (Feb 19, 2018)

  • Major Changes:
  • This release fixes a number of bugs and timing issues in version 5.7 mainly related to the code-generator.