Build History for branch/main

Upgrade ocamlformat to 0.27.0

Work around breaking change in `js_of_ocaml` 5.9.0 `js_of_ocaml` 5.9.0 started using `node:` prefixed modules, which do not exist on old node versions.

Upgrade to cohttp 6.0.0

Format code to reduce diffs

Separate tests of `Run` module

Don't refer to `caml_ml_domain_id` on OCaml 4 See #332 Co-authored-by: Hugo Heuzard <hugo.heuzard@gmail.com>

Fix typo

Fix typo

Specify `Spawn` more strictly with respect to cancelation Co-authored-by: Edwin Török <721894+edwintorok@users.noreply.github.com>

Grammar

Grammar

Grammar

Add another example using the lock-free hash table

Reduce memory use of external reference counting This uses the recently added `try_compare_and_remove` operation in the hash table to avoid having an extra `Atomic` indirection. This also simplifies the update logic.

Add an example of a randomized lock-free bag

Adjust logo color

Link to landing page

Add `P I C O S` logo

Fix `picos_std` package to depend on `picos_aux` Also, upgrade dependency on `backoff` from 0.1.0 to 0.1.1.

Make sure tests on OCaml-CI tests pass on Windows

Upgrade version number in `dune-project`

Release notes for 0.6.0

Refine the `Awaitable` abstraction The use of `Trigger` is exposed to allow awaiting for multiple things. The internal cleanup is made more robust to make sure awaitables will not be leaked.

Elaborate on the use of `Awaitable.(signal|broadcast)`

Clarify documentation of `Computation.canceler` Co-authored-by: Carine Morel <carine@tarides.com>

Fix the documentation of `Fiber.FLS.create` Co-authored-by: Carine Morel <carine@tarides.com>

Simplify sample mutex implementation

Grammar

Wordsmithing

Add futex-line `Awaitable` atomic location abstraction

Add a note about the use cases of `Trigger.from_action` Co-authored-by: Carine Morel <carine@tarides.com>

Remove file that was accidentally added in a previous commit

Add missing and useful ops to hash table

Use `Countdown` from `multicore-bench`

Make sure `sherlodoc` is installed when updating docs I noticed I had updated docs without `sherlodoc`, which results in not having the nice search bar with the docs. This should prevent that from happening again.

Move libraries to top for quicker navigation

And more tweaks to improve code size and performance

Further tweak to reduce stack usage

Tweak to reduce stack usage

And tweak more for performance

Delay pair destructuring to reduce code size

Explicitly call to raise error from tail position

Further tweak fast paths when (a)waiting or peeking computations

Another performance tweak This moves the conversion of completed state to an option to a non-inlined function, which allows the usually vastly more common case to be inlined.

Tweak for performance The `Returned | Canceled` cases are less likely. Grouping them together reduces code size and improves thruput.

Prefer `invalid_arg` over `assert` in `Fiber.unsuspend`

Tweak to reduce code size

Tweak to reduce stack usage

Minor tweaks to reduce code size

Minor performance tweaks

Use `picos.ocaml5.ml` on OCaml 5 and generate `picos.ml` on OCaml 4

Tweak to reduce code size

Minor performance tweaks Trigger operations do not need to be recursive.

Tweak conditionals with CAS It seems the native OCaml compiler generates suboptimal code when one uses the `||` or the `&&` operators.

Use dune to build picos core as a single file

Plug compiler generated space leaks in `Bundle` The lifetime of bindings referenced by a closure in OCaml may be incorrectly extended as a reference to the closure record is kept alive for too long. These changes work around that compiler bug by calling a non-inlined function at the start of the closure, which forces the compiler to generate code to extract all the bindings from the closure record and turn them into ordinary bindings.

A motivating example of structured concurrency

Note that canceling a promise does await for the fiber And also explain the reason behind this design choice within the sample library.

Further tweaks to reduce stack usage

Bench `(Bundle|Flock).join_after` memory usage

Also retry `socketpair` on `EINVAL` on Windows

Tweak to reduce stack usage of structured fibers

Tweak to reduce CPU stack usage of finalizers

Include stack usage in memory usage benchmark This also changes the label to emphasize that this include both stack and heap.

Build core on 4.12

Note and test that certain operations are not cancelable This can help to simplify and optimize code in some cases as these operations are often used in finalizers.

Optimize mutex and semaphore for speed on low contention

Add an example running Lwt and FIFOs in a single program

Remove version number from generated docs

Avoid `Fun.protect`, because it doesn't know about cancelation

Also retry `socketpair` on `ENOENT` on Windows

Add `lastly` as a safer alternative to `Fun.protect` The problem with `Fun.protect` is that it doesn't forbid cancelation propagation.

Change `poison` to `poison_at` and add `poison` with `?callstack` This should make `poison`able data structures more convenient to use.

Add `run_main` This is convenient for use with MDX, which does some magic when you refer to `Lwt`, which can break things.

Start release notes for next version

Number of alive fibers need not be atomic in the FIFO scheduler

Note on use cases of `Control.protect`

Warn about `Fun.protect`

Forbid cancelation propagation during `release` I was previously undecided on whether it should be done implicitly, but it has turned out to be surprising, so, now I'm convinced that the right thing to do is to forbid cancelation propagation during resource `release` calls. The issue is that if a fiber gets canceled, then resource `release` operations that might need to await for something asynchronous may not be properly run to completion. This can be surprising and, also, because this only happens in cases of cancelation, which could happen at any moment, could be a major source of subtle bugs. The downside of forbidding cancelation is that in some cases a `release` operation might block indefinitely and this can also cause issues. However, I believe those cases will be both harder to miss (your program hangs rather than leaks) and easier to debug (a debugger or stack trace should be able to point you to the `release` call).

Adjust amount of simulated work

Also retry socketpair on `EACCES`

Add an example of running a program with multiple sample schedulers

Fix doc references

Require multicore-bench 0.1.5 with better error handling

Remove unnecessary use of `Obj.magic ()`

Add `FLS.remove`

Test, just in case, that there are no FD leaks

Work around Uri not being thread safe See [issue in Uri](https://github.com/mirage/ocaml-uri/issues/178).

Fix to use `await` as there is a race

Use the new `Computation.peek_exn` when computation is completed The new `Computation.peek_exn` should be preferred over `Computation.await` in cases where the computation is supposed to be completed already.

Attempt to work around `Unix.socketpair` issue on Win32 `Unix.socketpair` occasionally fails on Windows: ```diff --- a/_build/default/lib/picos_io/picos_io.mli +++ b/_build/default/lib/picos_io/.mdx/picos_io.mli.corrected @@ -753,7 +753,5 @@ end send_string "Hello, world!"; send_string "POSIX with OCaml"; end - Hello, world! - POSIX with OCaml - - : unit = () + Exception: Unix.Unix_error(Unix.EADDRINUSE, "socketpair", "") ]} *) ``` This introduces a work around to retry `Unix.sockepair` a few times on Win32 when the `EADDRINUSE` error is raised. We shuld remove the workaround once the root issue is fixed.

Raise proper error when select has not been configured Also do not configure select during module level initialization in the test scheduler.

reflect version in opam files

Note that `Exn_bt` was removed

Test cross scheduler wakeup Similar behavior is also covered by the mutex and condition cancelation tests, but this is a simpler test and potentially useful on its own (i.e. this test can potentially tell that the bug is in the scheduler rather than mutex and condition).

Use GH action to check Picos core builds on OCaml 4.13

Rename `picos_stdio` to `picos_io` This avoids a linting warning on OPAM CI.

Release notes for 0.5.0

Allow test to fail on OPAM CI

Instruct to install `picos_stdio`

Link to all libraries in the `picos` package

chore: add a version field to dune-project cannot pin anything but picos otherwise, the versions won't match (opam picks the latest known version or "dev" otherwise, so picos gets version 0.4 and the other ones gets "dev" while requiring picos to also be "dev")

Try even harder to use all threads when there are ready fibers

Use same STM test count and time budgets on all targets This is now possible, because the tests are being run with a time based budget and that prevents tests from taking way too long on slower targets.

Fix documentation links

Split Picos into multiple packages and remove `Exn_bt` This splits the picos package into several smaller packages, roughly: - `picos` -> (`backoff`, `thread-local-storage`) - `picos_aux` -> (`backoff`, `multicore-magic`) - `picos_std` -> `picos`(, `backoff`, `multicore-magic`) - `picos_stdio` -> `picos_std`, `picos_aux`, and `unix`(, `mtime`, `psq`) - `picos_stdio_cohttp` -> `picos_stdio`(, `cohttp`, `fmt`, `uri`) - `picos_mux` -> `picos_std`, `picos_aux`, and optionally on `picos_stdio` - `picos_lwt` -> `picos_std`, `picos_aux`(, `lwt`) - `picos_meta` -> all of the above for integration tests and to simplify dependencies of other packages The above changes should make it easier for people to depend only on the packages they need. A single package with dependencies to `lwt` and `cohttp` is just too heavy. This also removes the `Exn_bt` module and type entirely. It is impossible to have such a module in OCaml. Due to the split to multiple packages the structure of the documentation has also been updated. Currently odoc doesn't support references between packages, which, unfortunately, downgrades the quality of the documentation.

Work around `Domain.spawn + Domain.join` not keeping stack traces

Use a quota when running tests with FIFO schedulers The quota is selected from the range [1, 100]: - A quota of 1 is an edge case worth testing. - A quota of 100 is high enough that fibers are unlikely to encounter it during most tests. This also changes the test scheduler to print details on the scheduler in case the `main` raises.

Optimize to not spawn for the last `main` with `Run.(all|any)`

Fix not stop looking for fibers to run as long as any are ready

Fix to really try to use all threads Whenever there are idle runners and ready fibers a runner is woken up.

Add `picos_multififos` to the binaries benchmark

Drop unnecessary dependency

Elaborate on event contract

Prefer `begin end` when grouping statements

Add a multithreaded (mostly) FIFO scheduler

Ensure `instantaneous_domain_index`

Add `Picos.Computation.peek_exn` (#245) * add `Picos.Computation.peek_exn` `peek` is often used in the fast path of some operations, so ideally it should not allocate. * perf: help `Exn_bt` functions be inlined for accurate results if `Exn_bt.get` isn't inlined it might clobber the current backtrace; if `Exn_bt.get_callstack` isn't inlined it would show its own frame? * doc * doc * minor refactor * Note on why we always inline `Exn_bt.get` and `Exn_bt.get_callstack` * Doc reformat --------- Co-authored-by: Vesa Karvonen <vesa.a.j.k@gmail.com>

Reduce minimum benchmark runs to avoid taking too much time on CI

Add `Picos_mpmcq.length` and tweak for performance

Also run `Picos_mpmcq` bench

Link to `Tx` documentation

Add `Picos_mpmcq` bench

Drop redundant divide by 1

Fix `Picos_mpmcq.pop_exn` incorrectly reporting queue as empty This is difficult to reproduce &mdash; I've witnessed this having happened exactly once on the CI, but the bug seems obvious as explained in #224.

Simplify FLS interface

Add a basic test for the `Computation.Tx` interface

Add a basic test for the `Computation.Tx` interface

Add a basic test for the `Computation.Tx` interface

Add transactional interface for completing multiple computations

Note about need to `Picos_select.configure` with multiple threads Addresses issue #234 Co-authored-by: Lee Koon Wen <koonwen@gmail.com>

Upgrade to `thread-local-storage>=0.2`

Adjusted spacing in comment

Add optional argument to terminate `Bundle` and `Flock` on return

Add internal `Q.add` helper

Must have yielder per fiber

Simplify semaphore benchmark fiber management

More links to reference

Which `picos_sync` test occasionally hangs?

Link to documentation index page

Add `Stdlib` style `Semaphore` module to `Picos_sync`

Use `sleep` instead of `yield` In this case, when using the randomized scheduler, `yield` may not let all of the children proceed.

Increase image size

Another link

More links

Links

Add hard deadline to cancelation test

Avoid creating lots of or unnecessary systhreads on OCaml 4

Link to libraries in reference manual

Fix to not cancel computation In case of spawn failure This seems to have been introduced in PR #210 and is not how spawn is specified to behave.

10k seems like a fine limit

Avoid spawning fibers in cancelation test It is not necessary to spawn fibers and doing so is very expensive on OCaml 4. It might be that this was the reason the test seems to hang occasionally on some OCaml 4 test machines. Could something go wrong and cause a thread never to run on OCaml 4?

Introduction to Picos

Update ecosystem diagram with some background for visibility

Add Picos ecosystem diagram

Symmetry

Adjust mutex bench for OCaml 4

Avoid entry reallocation

Must not use more than one domain Otherwise output may be garbled.

Prefer `Picos_randos` over `Picos_fifos` in MDX tests

Fix off-by-one error in `read_line`

Disable HTTP test based on OPAM_REPO_CI

Link to Cohttp project

Add an example of using Cohttp

Fix to fully transmit body I noticed that when using the bytecode interpreter the request/response body was not always properly transmitted --- a test will appear in a separate PR. This simplifies the client to not try to write things concurrently and changes both sides to shutdown the connection partially after being done with writing or reading. This seems to have eliminated the issue.

`s/funtions/functions/g`

Add minimalist Cohttp implementation using `Picos_stdio`

CI maintenance

Avoid check

Explain use as a building block of a multi-threaded scheduler

Add multi-producer multi-consumer queue allowing pushes to both ends

Drop default argument

Don't reduce remaining quota in `current` `Fiber.current ()` can be very performance critical. So, it is perhaps better not to make it any more expensive than necessary.

Fix `spawn` handler of `picos.fifos` to refer to current fiber

Use TLS to store current fiber in `picos.randos` This allows the effect handlers to be preallocated once and the space taken by a fiber reduced significantly.

Redesign `Spawn` and introduce concept of fatal errors

Fix to actually update the quota

Further optimize bundle and flock per fiber memory use

Also benchmark memory use of flocks

Add separate memory usage benchmark for promises in a bundle

Optimize `Bundle.fork` to not use per fiber computation Per fiber computation is only needed when a fiber is forked as a (separately) cancelable promise.

Reduce per fiber allocations in `picos.fifos`

Don't make people click links

Add a benchmark of memory usage

More permissive assertions to avoid flakiness

More flexible terminate to avoid flakiness

Refer to cancelation as a signaling mechanism

Note on calls from outside of a flock

Drop unused `bundle` parameter

Add an implicitly propagated flock of fibers

Prefer not to appear as an allocation

Edge case adjustments Changes: - Always `Trigger.signal` after transfer/release has completed. This just makes sense. - Capture stack trace in handlers explicitly before calling user given code. This has the downside that capturing a stack trace allocates, which is both expensive and, I assume, also allows an asynchronous exception. OTOH, in most cases it is likely better to ensure stack traces are captured properly. - Establish handler before call of`Trigger.signal`. As specified in the documentation, `Trigger.signal` should not raise, but it is perhaps better not to trust this.

Redesign resource management to use only one binding operator

Make example less flaky

Reuse internal `let_at`

Move `Picos_structured.Finally` into its own lib `Picos_finally` The `Finally` module is useful independently of the fiber management model provided by `Picos_structured`. This also introduces a number of changes: - The `finally` type is renamed to `template`. - The `moveable` type is renamed to `instance`. - The semantics of `let^` is changed such that it also releases the resource in case an exception has been raised in the scope. - A borrow mechanism is added, as the `let&` binding operator, to allow one to use a resource acquired as a resource `instance` before moving the resource to another scope. - A way to explicitly `release` the resource held by an `instance` movable is also added.

Add `Picos_randos.run_on` helper for running on multiple domains Also avoid using `Domain` and `Unix` modules in the examples in the documentation.

Set random seed for each QCheck STM round

Add deadline to mutex cancelation test On 4.14 presumably the mutex cancelation test sometimes takes too much time to get the desired number of various cancelation points. This explicitly limits the time the test is allowed to take.

Expand on comment

Tweak `Finally.(let^)` for performance This moves allocations to the same block (so the compiler can merge them), reduces total allocations by one word, and avoids an unnecessary `Atomic.set`.

Fix `Finally.move` to be lazy

Change `Control.block ()` to raise `Sys_error` when forced to return It is technically possible to finish the computation of a fiber from outside of the fiber when using the low level Picos interface so it is not strictly impossible for the `Trigger.await` inside `Control.block ()` to return `None`.

Add a few more blockers to the cancelation example

Limit running time of QCheck STM tests

Drop timeouts from the beginning to reduce flakiness

Add `Event.always`

Skip benchmarks with too many domains

Add a many-to-many, poisonable stream

Rename `Ivar.peek` to `Ivar.peek_opt`

Wordsmithing

Add couple of examples of using `Control.terminate_after`

Add incremental or single-assignment poisonable variable An `Ivar` can be implemented trivially using a `Computation`. This PR also adds an example of how one can move resources between threads using the resource management helpers provided by the `Picos_structured.Finally` module.

More descriptive names for tests

Prefer `LIFO` with computation `LIFO` is (likely) faster and doesn't matter when e.g. there is just one awaiter.

Reduce message counts in naïve bounded queue bench This benchmark seems to be taking too much time on some platforms. This likely means that the mutex implementation should be improved.

Try to avoid poll in `Control.terminate_after` between critical ops During a poll point the OCaml runtime may e.g. handle Ctrl-C (i.e. SIGINT) and raise an asynchronous exception that could cause leaks.

Move error handling out of hot code.

Add `Control.terminate_after` and `Bundle.terminate_after`

Fix bounded queue example to use `Condition.broadcast` Using `Condition.signal` is not correct in these cases, because it is possible that multiple fibers manage to start `Condition.wait` and a single `Condition.signal` does not wake up all of them. Another alternative would be to `Condition.signal` every time the queue is not empty or is not full.

Skip benchmarks with too many domains

Allow `let@` to be inlined This allows a decent optimizing compiler to eliminate the tuple allocation. Unfortunately, at the time of writing, `ocamlopt` is not such an optimizing compiler, but Flambda seems to be able to do it.

Fix all sample schedulers to complete the root computation

Add a naïve bounded queue benchmark

Prefer structured concurrency in tests

Avoid raw `Fiber.spawn` in tests

Add `Promise.terminate_after` Also avoid use of raw Picos API in tests.

Use `Bundle` in `Yield` benchmark Avoiding the use of the raw `Fiber` API.

Adjust timeouts to avoid flakiness

Simplify `Mutex` cleanup logic

Bench `Mutex` with higher fiber counts to exercise the queue

Use scalable `Countdown` in benchmarks

Prefer `LIFO` ordering

Use `copy_as ?padded` from `multicore-magic`

Fix `Picos_randos` to count alive fibers correctly The code for spawning fibers was probably copied from `Picos_fifos` and was also correct before enhancing `Picos_randos` to support running on multiple cores. With multiple runners the count must be updated before pushing new `Spawn`s into the collection, because otherwise the count may incorrectly become `0` too early.

Add blocker using `Latch` to cancelation example

Change to use the `Lwt_unix` notification mechanism Previously I had rolled my own version of a notification mechanism as I didn't know one already existed in `Lwt_unix`. This PR changes `Picos_lwt_unix` to use the existing mechanism provided by `Lwt_unix`.

Make select test less flaky by ignoring extra timeouts

Use multicore-bench with suite order randomization This exposes variation due to effects that individual benchmarks have on the runtime state.

Split assertion to get more detail

Document `Bundle` behaviour in more detail

Change `Control.block` to raise when cancelation has been forbidden

Wordsmithing

Fix wording

Add `Event.from_computation` and a `Promise.completed` event

Avoiding repetition and moving rarely needed info out of the top

Point to example in `Picos_select` library

Alternative design for composable events Co-authored-by: Simon Cruanes <simon.cruanes.2007@m4x.org>

Elaborate further on the ability to get a notification

Formatting

Note that the notification mechanism is the heart of computations

Include sizes of private sub libraries

CHANGES for 0.4.0

Add optional example using cohttp-lwt through Picos

Drop thunking from `Picos_lwt.await`

Wordsmithing

Try to avoid contention on back of the queue

Test on 5.2.0 on Windows Co-authored-by: Kate <kit-ty-kate@outlook.com>

Tweak code snippets

Change `Picos_lwt` to take `module System` as argument The `System` module is then used to give both a `sleep` function and a kind of trigger mechanism. The trigger mechanism is needed to be able to safely wake up Lwt in a multi threaded and/or multi domain program.

Finish computation to avoid leak on `EINTR`

Allow running test from the root of the project

Get `instantaneous_domain_index` at `create` to schedule `at_exit` See: https://github.com/ocaml-multicore/multicore-magic/issues/12 By getting the index at `create` the `Domain.at_exit` cleanup is hopefully registered early enough.

Implement `Picos_htbl` using `Atomic_array`

Use `make_contended` and forget about padding the main record

Bench hash table primarily by number of workers This avoids making the internal counter of the hash table wider than necessary.

Use `Atomic.make_contended`

Try to reduce sizes of libs

Avoid cost of `include` The `include` construct at the module level is quite expensive in terms of generated code size.

Allow to specify min and max buckets in `Picos_htbl`

Refer to Picos as an interface rather than as a framework

Initialize hash table on each benchmark round

Add bench of binary sizes This is useful for avoiding code bloat.

Perform `Picos_stdio.Unix` bench using multiple smaller blocks This mirrors change in a similar benchmark in multicore-bench.

Avoid allocating state when computation has no triggers attached

Try to make `select` test less flaky

Refactor to avoid code bloat in hash table This avoids some code duplication/bloat in the implementation of the operations (grow/split, shrink/merge, copy) over a whole hash table.

Bench exponential fib with `Picos_randos`

Bench on 5.2.x

Make hash table write ops more optimistic This could improve write performance.

Elaborate further

Rename `Picos_mpsc_queue` to `Picos_mpscq` This in preparation for further additions and also finally corrects the benchmark name, which used to refer to "foundation", which was an internal library that has since been removed.

Support multi-threaded use in `Picos_randos`

Elaborate on contracts

Report exceptions from server and client test

Optimize `Run` module operations This changes the implementation of `Run.any` and `Run.all` to only use the single computation of the bundle used internally.

Change `Picos_structured.Run.any []` to not block There are a number of reasons for making this change. While it sort of makes logical sense to block on an empty list, that can also be surprising and undesirable. This has also come up as an opinion in private communications. For example, suppose you want to use `Run.any` to start actions to try to search for a solution concurrently and the list of actions to use in the search is dynamically created. A simple program such as ```ocaml let solution = Atomic.make None in ... Run.any search_actions; match Atomic.get solution with | None -> ... | Some solution -> ... ``` might unexpectedly block in case the list of actions would be empty. The above also illustrates that it is typically not difficult to implement the blocking semantics on top of the non-blocking semantics (i.e. just block in the `None` case). It is still allowed to cancel individual fibers started with `Run.any`. Consider ```ocaml Run.any [] ``` and ```ocaml Run.any [ fun () -> raise Control.Terminate ] ``` Is there a difference between the two? Should both block and, if so, does that open more possibilities to write unexpectedly blocking code? OTOH, disallowing canceling fibers used with `Run.any` (and `Run.all`) by raising `Control.Terminate` would seem to introduce an inconsistency with respect to other constructs in `Picos_structured`. I'm happy to revisit this later in case more motivating examples arise.

Avoid allocations in `Picos_randos`

Add `Picos_randos` — a randomized scheduler This introduces a randomized scheduler intended for testing. This seems to be quite effective for finding bugs related to cases where code implicitly depends on scheduling. It already revealed bugs during development.

Test that `Run.any` and `Run.all` return as expected Also `shuffle` lists of actions

Prefer Format with fewer lines

Terminate is not counted as an error

Test `Run.all` and `Run.any` report exceptions started actions

Prefer links

Increase time bounds The upper bound could also be just removed.

Test `Run.all` collects all errors

Move examples to bottom of page

Fine tune MPSC queue docs

Move away from MDX based tests Well, I gave MDX a chance, but then I realized one test wasn't even run, because I had misspelled the filename and MDX integration gave no indication of this whatsoever. I also find it very hard to debug MDX based tests. So, from now on MDX will only be used to check examples rather than write more serious tests.

Add `pop_all` to `Mpsc_queue`

Make racing test less likely to fail due to non-determinism

Adjust docs

Add an example demonstrating and explaining cancelation

Documentation adjustments

Add minimalistic `Promise` to `Picos_structured` The `Promise` API could be extended in various ways, but I will leave that to future work.

Defunctorize `Picos_lwt` I realized there is no need to use a functor. `await` could be just moved outside of the functor and `sleep` is a monomorphic function, which can easily be passed around - a functor is overkill.

More mobile friendly

More mobile friendly formatting

Make the forbid argument optional in sample schedulers It still makes sense to require the fiber operations to have it mandatory, because those are not user level operations and should be as fast as possible.

More mobile friendly formatting

More mobile friendly formatting

Fix typos in docs

CHANGES for 0.3.0

Add basic structured concurrency library

Picos compatible direct style interface to Lwt

Upgrade ocamlformat from 0.26.1 to 0.26.2

Perfer a one-liner

Adjust non-deterministic time bound

Couple of simple `Unix.select` tests

Add `Unix.select` to `Picos_stdio`

Enable tests on Win32 Enable openfile and read test on Win32. Operations on files are essentially non-blocking. Using sockets we can also do non-blocking IO on Windows.

Prefer to use unique exception

Adjust wording

When `threads.posix` exists we really need `thread-local-storage` `thread-local-storage` is needed for correct operation when `threads.posix` exists. TLS is used to store the fiber identity with `picos.threaded` and that breaks without proper TLS. I've now run into this a couple of times that I missed `thread-local-storage` from the switch and that unfortunately allowed an invalid build where `threads.posix` (and hence systhreads) existed without `thread-local-storage`.

Prefer shorter nominal form

Add basic tests using MDX MDX makes it easy to add some simple tests.

Use seeded hash

Synchronize explicitly to ensure order of events

Wording

Some more examples

Add some examples to documentation

Put intent first

Link to operations

Adjust formatting

Fix sentence

Better to not try to have bullets with `modules`

Documentation tweaks

Check FD use more carefully

Simplify select loop

Ensure `Picos_select` is configured early enough

Fix links

Plural is more

`CHANGES` for 0.2.0

Document some common conventions

Scale STM `count` parameter to avoid taking too much time on CI

Document the optional `padded` argument

Add custom index page for the package and restructure the intro

Wordsmithing

Don't start select thread unless sigchld is handled by us

Support `Unix.wait` and related functions in `Picos_stdio`

Add `Picos_htbl.remove_all` Remove all bindings and return them as a sequence atomically.

Add `Picos_htbl.remove_exn` to atomically find and remove a binding

Make `Picos_select` explicitly configurable

Move `Picos_tls` under `Picos_thread.TLS`

Adjust wording

Let `picos.threaded` depend directly on `threads.posix`

Adjust comment formatting

Depend optionally on `picos.select`; allow `cancel_after` to raise

Account for potentional exceptions in test

Allow resume from signal handlers While [`pthread_cond_broadcast`](https://pubs.opengroup.org/onlinepubs/007904975/functions/pthread_cond_broadcast.html) is not safe to call from a signal handler, the situation in OCaml is somewhat different as [signal handlers in OCaml are called during poll points](https://ocaml.github.io/ocamlunix/signals.html#sec86) on some thread. The change in here makes an assumption that there is no poll point in `Condition.wait` before the thread has been suspended and can be resumed by a `Condition.broadcast`. If this is the case, then it should actually be possible, under the right circumstances, to use `Condition.broadcast` from a signal handler to release a waiting thread.

Fix typos

Scheduler friendly `Picos_stdio.Unix.sleep*`

Emphasize every `req` must `clr`ed exactly once

Serve `picos.svg` from `githubusercontent` to show on ocaml.org docs

Warn about setting shared fds to nonblocking mode

Warn about broken signals in OCaml 5.0.0

Remove TODO list (moved to issues)

Allow to skip server and client test on Opam CI

Don't depend on npm on riscv

Drop reference to deleted library

Add brief description

Warn that Picos is unstable

Drop redundant `package` fields

Front matter

Use `with_action`

Clarify the internal `intr_pending` counter increment

Link to benchmarks on `pascal`

Add `Picos_stdio` benchmark

Add interrupt support and implement async IO for blocking FDs

Fix wakeup state machine

Add `Computation.with_action`

Add `Computation.with_action`

Add `Computation.with_action`

Add `Computation.with_action`

Add `Picos_htbl.mem`

Refactor to extract deadline computation

Prefer to explicitly use `Fun.id`

Avoid race condition in `Lazy` cancelation test With a multithreaded scheduler it was possible for the `Trigger.await` inside the lazy computation to observe the trigger as signaled before performing `Await` where the scheduler would notice that the fiber was canceled.

`CHANGES` for 0.1.0 and documentation tweaks

Adjust links in doc comments

Drop `picos.ptmc` Seems superfluous with the current design. Can be added back later if needed.

Add ref counting for disposable resources and `picos.stdio` library

No summer without opam as owner

Adjust `(libraries ...)`

On Win32 `Unix.select` timeout seems to have really bad resolution

Avoid allocations in handlers

More links between libraries

More benchmarks

Add `HACKING.md`

Fix wording

Add `CHANGES.md` starting to prepare for first release

Add `picos.sync` library

Add `Fiber.try_suspend` and `Fiber.unsuspend` helpers I noticed I had failed to account for one case in my previous `await` handler implementations. This fixes that by introducing a pair of helpers for suspending and unsuspending a fiber.

Add `yield` benchmark

Mention physical equality

Prefer public names when available

Avoid `domain_shims` in bench

Limit test iterations on 32-bit platforms

Drop uses of `open struct ... end`

The `Fiber.current ()` operation must never propagate cancelation The problem is that in order to call `Fiber.forbid fiber (fun () -> ...)` to forbid cancelation, it is necessary to call `Fiber.current ()` to obtain the `fiber`. Hence `Fiber.current ()` must not propagate cancelation. In some cases one could call `Fiber.current ()` well before performing the work that needs to be protected by `Fiber.forbid ...`, but this is not always practical.

Publish the sample FIFO scheduler

Document and simplify threaded sample OCaml 4 scheduler

Reorganize `lib` dir to separate core, i.e. `picos`, library clearly The point is to make it easier to see what the core library consists of.

Adjust TODOs

Use `TLS` to store handlers on OCaml 4

Avoid unnecessary wakeup

Avoid unnecessary wakeup

Add `Computation.wait`

Documentation tweaks

Fix documentation of `is_initial`, whose behavior changed recently

Simplify signature with wildcards

Add (private) `Picos_thread_atomic` library

Add `Picos_select.await_on` for convenience

Fix reference to `Computation` in doc comment

Minimalistic `Unix.select` event loop for Picos

Avoid duplication of `Computation.await`

Remove default behaviors on OCaml 5

Upgrade to multicore-bench 0.1.2

Avoid wide match

Add `alert` attributes to dangerous operations

Optimize `canceler` to avoid allocations

Tweak warnings in documentation

Prefer punning notation

Avoid float array pessimization

Add benchmark of `FLS` excluding cost of `Current`

Test `FLS` with a `float` key

Add some more flesh to the documentation This also adds - `Trigger.from_action` for special uses cases needed by schedulers, and - `Trigger.dispose` for safer disposal of triggers inside schedulers.

Allow to specify the order for signaling triggers on completion The order has an effect on scheduling so it makes to allow it to be specified.

Add benchmark for attach detach pairs

Signal triggers in LIFO order at computation completion

Elaborate on the intent of `forbid`

Drop phantom types

Add an example of how to await for one of any number of computations

Clarify comment on lazy removal of triggers

Upgrade DSCheck to allow OCaml-CI test on OCaml 4

Adjust number of messages based on number of takers

Add link to benchmarks

Rewrite benchmarks to run on current-bench

Add link to Fuseau

Test with 5.1.1 on Windows and use sunset repository

Minor refactor to keep `t` as first and `backoff` as last argument

Add `try` versions of `Computation` completion actions While the result is often not interesting, there are cases where knowing whether a particular call completed the computation can be useful.

Testing with DSCheck

Add benchmark of the MPSC queue