from Hacker News

OCaml Multicore merged upstream

by sadiq on 1/10/22, 2:39 PM with 74 comments

• by tialaramex on 1/10/22, 4:17 PM

  Interesting. As I understand it, this lands an approach in which Sequential Consistency is not guaranteed but if you have a data race you get even nicer guarantees than in Java and its authors believe this might be enough that real programmers working on real software can actually debug data races despite loss of sequential consistency.

  In many popular languages today (e.g. C++) if you have a data race you're completely screwed, (e.g. the program exits successfully, even though it was supposed to loop forever serving TCP requests - good luck figuring out why). In Java they decided OK, that's not acceptable, so data races are constrained to only the data touched by the race and, importantly, that data is still legal it just might be astonishing (e.g. you were adding several small positive integers together from a shared data structure in parallel, but due to a misunderstanding in your design this was actually a data race, and some time later somehow your total is now zero, but you won't crash or whatever)

  OCaml intends to further constrain the consequences in time, if the total was 114 when you stopped adding, it will still be 114 later, it won't mysteriously become zero (or any other value) thanks to a data race which must have happened before you checked.

  [I'm sure I have some details wrong, but this is the gist]

  What remains to be seen is: Is that enough? There was great hope when Java made its rules that they were enough and programmers could understand what was wrong in a Java program with data races, that did not pan out as I understand it. So, it seems to me that it's possible OCaml ends up in the same situation.

• by eatonphil on 1/10/22, 5:17 PM

  If you're interested to see a comparison of parallel programming in a number of functional languages check this repo out [0]. It includes multicore OCaml, parallel MLton (but not Poly/ML, which has been around and parallel longer), Haskell, Futhark, F#, Scala, and Rust.

  Credit to Sam Westrick for turning me on to this [1].

  [0] https://github.com/athas/raytracers

  [1] https://twitter.com/shwestrick/status/1480587660691480579

• by dang on 1/10/22, 5:51 PM

  From three weeks ago:

  PR to Merge Multicore OCaml - https://news.ycombinator.com/item?id=29638152 - Dec 2021 (155 comments)

  Past related threads:

  Multicore OCaml: October 2021 - https://news.ycombinator.com/item?id=29238972 - Nov 2021 (12 comments)

  Effective Concurrency with Algebraic Effects in Multicore OCaml - https://news.ycombinator.com/item?id=28838099 - Oct 2021 (59 comments)

  Multicore OCaml: September 2021, effect handlers will be in OCaml 5.0 - https://news.ycombinator.com/item?id=28742033 - Oct 2021 (3 comments)

  Multicore OCaml: September 2021 - Effect handlers will be in OCaml 5.0 - https://news.ycombinator.com/item?id=28719088 - Oct 2021 (3 comments)

  Adapting the OCaml Ecosystem for Multicore OCaml - https://news.ycombinator.com/item?id=28440385 - Sept 2021 (1 comment)

  Adapting the OCaml Ecosystem for Multicore OCaml - https://news.ycombinator.com/item?id=28373155 - Aug 2021 (21 comments)

  Multicore OCaml: July 2021 - https://news.ycombinator.com/item?id=28039219 - Aug 2021 (14 comments)

  Multicore OCaml: May 2021 - https://news.ycombinator.com/item?id=27480678 - June 2021 (27 comments)

  Multicore OCaml: April 2021 - https://news.ycombinator.com/item?id=27140522 - May 2021 (89 comments)

  Multicore OCaml: Feb 2021 with new preprint on Effect Handlers - https://news.ycombinator.com/item?id=26424785 - March 2021 (29 comments)

  Multicore OCaml: October 2020 - https://news.ycombinator.com/item?id=25034538 - Nov 2020 (9 comments)

  Multicore OCaml: September 2020 - https://news.ycombinator.com/item?id=24719124 - Oct 2020 (43 comments)

  Parallel Programming in Multicore OCaml - https://news.ycombinator.com/item?id=23740869 - July 2020 (15 comments)

  Multicore OCaml: May 2020 update - https://news.ycombinator.com/item?id=23380370 - June 2020 (17 comments)

  Multicore OCaml: March 2020 update - https://news.ycombinator.com/item?id=22727975 - March 2020 (37 comments)

  Multicore OCaml: Feb 2020 update - https://news.ycombinator.com/item?id=22443428 - Feb 2020 (80 comments)

  State of Multicore OCaml [pdf] - https://news.ycombinator.com/item?id=17416797 - June 2018 (103 comments)

  OCaml-multicore now at 4.04.2 - https://news.ycombinator.com/item?id=16646181 - March 2018 (4 comments)

  A deep dive into Multicore OCaml garbage collector - https://news.ycombinator.com/item?id=14780159 - July 2017 (89 comments)

  Lock-free programming for the masses - https://news.ycombinator.com/item?id=11907584 - June 2016 (29 comments)

  Lock-free programming for the masses - https://news.ycombinator.com/item?id=11893911 - June 2016 (4 comments)

  OCaml 4.03 will, “if all goes well”, support multicore - https://news.ycombinator.com/item?id=9582980 - May 2015 (113 comments)

  Multicore OCaml - https://news.ycombinator.com/item?id=8003699 - July 2014 (1 comment)

• by gautamcgoel on 1/10/22, 3:34 PM

  Been reading about this work for years, really cool to see it get merged! I recently came across a neat interview which describes upcoming changes to the OCaml GC and memory management system, which apparently lead to huge performance gains:

  https://signalsandthreads.com/memory-management/

• by sadiq on 1/10/22, 2:48 PM

  As usual I'm happy to answer any questions I can.

  (for maybe the second to last time)

• by harporoeder on 1/10/22, 3:48 PM

  Amazing to see this merged. As far as I can tell this work goes all the way back to 2014 (1), and has been a huge effort.

  1. https://ocaml.org/meetings/ocaml/2014/ocaml2014_1.pdf

• by nu11ptr on 1/10/22, 3:42 PM

  Congrats - this is a big hurdle to adoption that is now gone. The engineering that went into this is impressive.

• by the-alt-one on 1/10/22, 4:01 PM

  It's been a long time since I was hyped about something in programming! Very cool, I really want to try OCaml now.

• by codeptualize on 1/10/22, 4:53 PM

  Congrats on the merge, big achievement!

  I have been interested in OCaml for a while (mainly because of ReasonML), never really got to it unfortunately, but maybe this is the time.

• by exdsq on 1/10/22, 4:43 PM

  Is anywhere other than Jane Street using OCaml? :)

• by saati on 1/10/22, 4:28 PM

  OCaml was single threaded until this or what is this exactly? There is no description of what the PR does which is pretty bad form.

• by pjmlp on 1/10/22, 4:55 PM

  Congratulations on the accomplishment!

• by devmunchies on 1/10/22, 5:43 PM

  the PR adds effect handlers (`stdlib/effectHandlers.ml`). Does that mean work will begin to start replacing Async+Lwt with a native alternative?

• by mgaunard on 1/10/22, 5:00 PM

  I'm familiar with the C++11 object model.

  How does OCaml compare?

  From a quick skim of papers, it seems it provides sequential consistency when using atomics and acquire/release semantics when not.

  Sounds like a pretty bad design.

• by carlsborg on 1/10/22, 3:53 PM

  Any perf benchmarks?

• by xvilka on 1/10/22, 3:54 PM

  Best news of the day! Is there any roadmap for typed effects?

• by foobarloo2 on 1/10/22, 5:30 PM

  Very interesting.