OCamlPro/opam-repository — pull request #815 by ysulsky (2013-06-19 22:27:22+00:00)
Title: core 109.30.00 + fixes to inotify

## core
- Created submodule `Core.Signal.Expert` module.

This is for functions previously in `Core.Signal` that introduce
multithreading semantics, and are hence hard to reason about and
should only be used by experts.

## core_kernel

- Added module, `Core.Blit`, which codifies the type, implementation, and unit-testing of blit functions.

- Added `remove_zero_flags` option to `Flags.Make`, to support flags that are zero.

This fixes a problem with `Flags.Make` on CentOS 5 because `O_CLOEXEC` is `0` there.

- Removed `Pool.None`, and folded `Pool.Obj_array` into `Pool` proper.

`Pool.None` had its day, but `Pool.Obj_array` dominates it, so we don't need it any more.

## core_bench

- Report compaction stats

## async_core

- Added function `Throttle.kill`.

`Throttle.kill` aborts all jobs that have been enqueued but not
started, and immediately aborts all jobs subsequently enqueued.

Split out `Throttle` debugging and unit-testing code into their own
modules.

- Changed the semantics of `Throttle.enqueue` on a dead throttle so that the
exception is sent to the monitor rather than raised synchronously.

This gives more uniform treatment to the race between enqueueing a job
and an already running job raising. Now the enqueued job is always
aborted, whether enqueued before or after the raise.

- Added an ASYNC_CONFIG option to print debug messages when `Monitor.send_exn` is called.

This is useful when one is debugging an application in which an
exception is being unexpectedly swallowed.

- Allow one to dynamically configure the behavior of `Monitor.try_with`.

This is to allow experimentation with different handling of
asynchronous exceptions after `Monitor.try_with` has become
determined.

## async_unix

- Changed aync's scheduler to use `epoll` rather than `select` by default.

This is based on a dynamic test to see whether `timerfd_create` works.

- Added support for "busy polling".

This runs a thread that busy loops running user-supplied polling
functions. The busy-loop thread is distinct from async's scheduler
thread, but it acquires the async lock so that the user-supplied
function can do ordinary async operations, e.g. fill an ivar.

Busy polling is useful for a situation like a shared-memory ringbuffer
being used for IPC. One can poll the ringbuffer with a busy poller,
and then when data is detected, fill some ivar that causes async code
to handle the data.

- Added `Async.Fd.clear_nonblocking`.

This clears the nonblocking bit on the file descriptor underlying the
fd, and causes async to treat the fd as though it doesn't support
nonblocking I/O.

This is useful for applications that want to share a file descriptor
between async and non-async code and want to avoid `Sys_blocked_io`
being seen by the non-async code.

## ocaml_plugin

- Support for Mac OSX

Removed the dependency of `ocaml-plugin` on `objcopy` and `/proc`.