0.3.0

CHANGES:

• Set the internal pipe used to interrupt a domain to a non-blocking mode and
  remove the usage of an atomic which protect how we fill the pipe
  (@haesbaert, @dinosaure, #28)
• Expose option to reuse addr/port when we Miou_unix.bind_and_listen
  (@ada2k, @dinosaure, #27)
• Protect an illegal access to the orphan from a possibly parallel task which
  does not own the orphan value
  (@poytypic, @dinosaure, #31, #32)
• Be able to pin a specific domain when we want to launch a parallel task
  (@dinosaure, #34)
• Expose the Miou.Backoff module which can be useful for users
  (@dinosaure, #35)
• Fix or improve (from the maintainance point-of-view) the Miou.Queue module
  and some internal parts of Miou about the usage of atomics
  (@dinosaure, @polytypic, #36, #33)
• Prefer to require a finaliser function for the events value and actually
  close the internal Unix.pipe used to interrupt domain than to use
  Gc.finaliser and possibly leak file-descriptors
  (spotted by @hannesm, @dinosaure, #37)

0.2.0

CHANGES:

• Don't try to abusively fill the pipe to interrupt a domain

  Interrupting a domain involves writing to a pipe to interrupt the select(2)
  if it is running. The pipe has a limited memory, depending on the system, and
  if you ask to interrupt a domain too much, you end up blocking the write.
  This patch prevents writing to the pipe if it has not yet been read.

  (@dinosaure, #46)

• Expose the Sequence module
  (@dinosaure, #47)

• Be able to add a hook (effect free) into the scheduler

  It is possible to add a hook to the scheduler. If the user wants to execute a
  function to a domain each time the domain is busy with a task, they can do so.
  However, the effects are not managed in the passed function.

  (@dinosaure, #48)

• Add Miou.Lazy, a domain-safe Lazy module like Stdlib.Lazy
  (@dinosaure, initially implemented by @polytypic, #49)

• Raise an exception if the user uses syscalls (from Miou_unix) and Miou.run
  instead of Miou_unix.run

  If a user uses a suspend function offered by Miou_unix but does not use
  Miou_unix.run, the programme may block indefinitely. This patch prevents
  such an error by raising an exception if we want to add a suspension point and
  we haven't specified how to handle it (if we use Miou.run instead of
  Miou_unix.run).

  (@dinosaure, reported by @kit-ty-kate, #51)

• Rename Miou.set_signal to Miou.sys_signal
  (@dinosaure, #50)

• Improve Miou_unix.{read,write}
  (@kit-ty-kate, @dinosaure, #52, 2f552a6, #54)

• Fix an issue related to the dom0 and pending tasks locked by mutexes

  Tasks may have been transmitted to dom0 while it was executing a task and
  before the select(2). This patch resynchronises the pending tasks in dom0's
  TODO-list before making the select(2): specifically to find out whether the
  select(2) can block indefinitely or not. This patch also cleans up the old
  states of the tables used by Miou_unix if it is used on an ongoing basis (as
  in the case of tests).

  (@dinosaure, #53)

• Add Miou.Domain.available
  (@dinosaure, #53)

• Fix a race condition (observed with TSan) when we wait the cancellation of a
  children

  This patch changes Miou's behaviour a little when waiting for a task to be
  cancelled and prevents invalid access to a value that does not belong to the
  current domain (and which can be modified by another domain). Thanks
  @OlivierNicole and @fabbing for their advice on using TSan.

  (@dinosaure, #56)

• Update the layout of Miou to avoid conflicts with other packages (like backoff)
  (@dinosaure, reported by @patricoferris, #57)

• OCaml 5.3 support
  (@kit-ty-kate, github#22)

• Rename Miou.call_cc to Miou.async
  (@dinosaure, @kit-ty-kate, @Armael, github#23)

0.1.0

CHANGES:

A major change in Miou's internals to incorporate the excellent work of
Vesa Karvonen available in his picos project. This change
integrates the Trigger module and the Computation
module. It also uses the Await effect, which we hope will be
standardised.

This addition has enabled us to integrate the new Condition and
Mutex modules.

This change has enabled us to correctly formalise the resources used by our
scheduler and to release them accordingly, particularly with regard to the
cancellation whose behaviour is better defined.

We also took the opportunity to integrate the priority queue extracted from the
Vocal project and checked using Why3. We would like to thank
their authors and maintainers for their help.

Finally, the API has changed very little and only ownership is no longer
mandatory when using the Miou_unix module but is still available
through the Miou_unix.Ownership module.

As such, we have written a tutorial that explains in detail what
Miou can offer and how to create applications with it. It's also a good
introduction to using effects and implementing a mini echo server and mini
scheduler.

The changes are far too profound to establish an accurate Changelog since the
last beta. However, we have tried to respect our previous tests as much as
possible and ensure continuity in what Miou has to offer despite its beta
status. We hope that, given the changes described above, users will understand
this breaking-change.

0.0.1~beta2

CHANGES:

• Composition between Miou and user-defined effects. @dinosaure
  664e8e26ec861c4fe3672144eead70b42f5fdbe5

  Miou includes a mechanism that allows you to create an effects manager using
  Miou's effects manager. The latter always respects the rule: one effect
  yields. The documentation has been updated accordingly. Tests 28 and 31 show
  an example of effect composition.

• Integrate the test t26 & t27. @dinosaure
  885d86eeedede3b28f6467bc2f0343b2ccf71225

  Test 26 verifies that Miou does indeed perform an infinite loop if a system
  event handler has not been installed and Miou.suspend is used. Test 27 is
  used to check Miou's behaviour with Miou.yield.

• Fix the happy-eyeballs example & cancelled suspension points. @dinosaure
  ffa2fc059d62bf580ed6d090aaf33e26fe9571e8
  bf47c1a83ad5b8607dd097b6a1547cc18c0527c8

  When a task is cancelled, we have to clean up the suspension points created
  in this task. The code has been factorised to avoid duplication between
  happy-eyeballs and dns.

• breaking change Be able to know if an orphans still have few tasks or
  not. The Miou.care returns an 'a t option option where:

  • Some (Some _) is a ready-to-await task
  • Some None informs that some tasks still exists but they are not finished
  • None informs that the orphans has no more tasks

  @dinosaure
  0560a14ea848466ea99792d27138c47f71aab747

• Protect the dom0 from user's exceptions. @dinosaure
  0dd647e15a859d458d6daf3ca96e3e65a30ce30f

• breaking change The give argument no longer transfers ownership to the
  new task, but copies ownership so that the task that created the new task
  and the new task have ownership of the resource. @dinosaure
  55ff54ddfd585f52fcda4d56caf2458760a7f949

• Add Miou_unix.shutdown (like Unix.shutdown). @dinosaure
  7f37ed6645965552a34070b23177dfdc4dda01fd

• Clean shutdown of the domain pool if one of the domains raises an exception.
  @dinosaure
  27f3d1d09a170212ab291daad214da3511d972a4

• Add a self function: This function lets you know which promise you're in. It
  provides information such as the domain executing the task, the promise
  identifier and the number of resources it is responsible for. @dinosaure
  0b1833f623e61b674105cdced64aa624f2a6340e

• Expose partially our Logs module. @dinosaure
  e4062178f4dee18a97fbc3ebb6fb36352d9ff9f5

• Be able to handle multiple suspension points for the same file-descriptor.
  @dinosaure
  1728d2600d0177f9422474bb41a1f12a111e6658

• Use Heapq instead of an Hashtbl to handle sleepers. @dinosaure
  32e0b8adc7a6a92e14dae12d1fa1991ce41f71a5

• Avoid CSE optimisation via Sys.opaque_identity. @polytypic @dinosaure
  5bcdaf4dd4fbf404cfb6f89b06280e12298c50cc

• Reverse control of task waits. Previously, Miou systematically added a step if
  we wanted to wait for the result of a task. If the task was completed, we
  ended up giving the result after several observations of the promise, which
  could be slow in certain situations.

  Now, waiting for a task attaches the continuation to the promise. If the task
  associated with the promise finishes, we simply "continue" with the value
  obtained avoiding a systematic observation of the state of the promise until
  the task finishes.

  @dinosaure
  d795f08fc64f3e53077172dbfedfcefe47a2b832
  42ef35bafa21ea0c264f6f3519fcb72732c1abd8

• Expose [Miou_unix.on_{read,write}]

  @dinosaure
  27174019f959414051bfbdb5057a17e6b7a036ee

• Fix the documentation about [Miou.call] and the possible situation where no
  domain are available to execute a parallel task

  @dinosaure, @zapashcanon
  aab9996ab2a3a59db2fed59f8ed997ef6f5abe14

0.0.1~beta1

CHANGES:

• First release of miou