CODEWITHSUNDEEP
functional-programmingocaml
Jackson Tale
Jackson Tale

Reputation: 25842

Why is OCaml still reasonable fast while constantly creating new things?

OCaml is functional, so in many cases, all the data are immutable, which means it constantly creates new data, or copying data to new memory, etc.

However, it has the reputation of being fast.

Quite a number of talks about OCaml always say although it constantly creates new things, it is still fast. But I can't find anywhere explaining why.

Can someone summarise why it is fast even with functional way?

Upvotes: 1

Views: 761

Answers (3)

Ashish Agarwal
Ashish Agarwal

Reputation: 3030

Also, you should know that copies are not made nearly as often as you might think. Only the changed part of an immutable data structure has to be updated. For example, say you have an immutable set x. You then define y to be x with one additional item in it. The set y will share most of its underlying representation with x even though semantically x and y are completely different sets. The usual reference for this is Okasaki's Purely Functional Data Structures.

Upvotes: 7

Jerry101
Jerry101

Reputation: 13427

I'm not familiar with OCaml but here's some general background on programming language VM (including garbage collection) speed.

One aspect is to dig into the claims -- "fast" compared to what?

In one comparison, the summary is "D is slower than C++ but D programs are faster than C++ programs." The micro-benchmarks in D are slower but it's easier to see the big picture while programming and thus use better algorithms, avoid duplicate work, and not have to work around C++ rough edges.

Another aspect is to realize that modern garbage collectors are quite fast, that concurrent garbage collectors can do most of the work in another thread thus making use of multiple CPU cores in a way that saves time for the "mutator" threads, and that memory allocation in a GC environment is faster than C's malloc() because it doesn't have to search for a suitable memory gap.

Also functional languages are easy to parallelize.

Upvotes: 1

Jeffrey Scofield
Jeffrey Scofield

Reputation: 66823

I think the essence, as Jerry101 points out, is that you can make GC a lot faster if it's known to be working in an environment where virtually all objects are immutable and short-lived. You can use a generational collector, and virtually none of the objects make it out of the first generation. This is surprisingly fast.

OCaml has mutable values as well. For some cases (I would expect they are rare in practice) you could find that using mutability makes your code slower because GC is tuned for immutability.

OCaml doesn't have concurrent GC. That's something that would be great to see.

Another angle on this is that the OCaml implementors (Xavier Leroy et al) are excellent :-)

The Real World OCaml book seems to have a good description of GC in OCaml. Here's a link I found: https://realworldocaml.org/v1/en/html/understanding-the-garbage-collector.html

Upvotes: 5

Related Questions