Question

It’s supposedly faster than a vector, but I don’t really understand how locality of reference is supposed to help this (since a vector is by definition the most locally packed data possible — every element is packed next to the succeeding element, with no extra space between).

Is the benchmark assuming a specific usage pattern or something similar?

How this is possible?

Answer 1

There is a lot of good stuff in the other answers but nobdy answers your question. The PersistenVectors are only fast for lots of random lookups by index (when the array is big). “How can that be?” you might ask. “A normal flat array only needs to move a pointer, the PersistentVector has to go through multiple steps.”

The answer is “Cache Locality”.

The cache always gets a range from memory. If you have a big array it does not fit the cache. So if you want to get item x and item y you have to reload the whole cache. That’s because the array is always sequential in memory.

Now with the PVector that’s diffrent. There are lots of small arrays floating around and the JVM is smart about that and puts them close to each other in memory. So for random accesses this is fast; if you run through it sequentially it’s much slower.

I have to say that I’m not an expert on hardware or how the JVM handles cache locality and I have never benchmarked this myself; I am just retelling stuff I’ve heard from other people 🙂

Edit: mikera mentions that too.

Edit 2: See this talk about Functional Data-Structures, skip to the last part if you are only intrested in the vector. http://www.infoq.com/presentations/Functional-Data-Structures-in-Scala