Remove the Op API

[polytypic]

This PR proposes to remove the Op or the low level multi-word compare-and-set (MCAS) API.

Why remove it?

It is typically much harder to program with the lower level MCAS API, because it basically requires you to manually

• keep track of values read from locations,
• create retry loops, and
• use backoffs,

which are all taken care of for you when using the transactional API.

The Xt API also offers further conveniences and fundamental abilities like composability, nesting, blocking, and timeouts that are not supported by the Op API.

Having the Op API is probably an unnecessary distraction for most potential users.

Also, it is relatively easy to implement an Op like API using the Xt API:

type cas = CAS : 'a Loc.t * 'a * 'a -> cas

let rec casn ~xt = function
  | [] -> true
  | CAS (loc, before, after) :: ops ->
    if not (Xt.compare_and_set ~xt loc before after) then
      raise_notrace Exit;
    casn ~xt ops

let atomically ops =
  try Xt.commit { tx = casn ops } with Exit -> false

The overhead of the above is slightly higher than that of the direct Op implementation.

Note that above is different from the existing Op API, because the above allows multiple ops to update the same location, which is not allowed by the Op API. The behavior to reject such overlapping ops could be implemented using Xt.is_in_log at the cost of some additional overhead (which could also be asserts).

OTOH, the above kind of approach also opens the possibility of using some more advanced data structures to represent the ops instead of as just lists, which could allow more flexible and efficient composition of (such intermediate) ops.

It will likely also be possible to specialize the implementation better for transactions. Currently both the Op API and the Xt API share some implementation. After removing the Op API it might be possible to specialize the internal implementation for the Xt API and reduce overheads a little bit.

[lyrm]

I also think that simplifying Kcas's API by removing the Op module is a good move.

Users that needs to chain operations should use the transactional API. It is less error prone and also way more powerful.

Also the 2 APIs (Op and Xt) are completely different so it does make Kcas less accessible in a way that users can loose time trying to use Op before understanding they need Xt and then they have a whole new API to get.