implement zeros() by calling calloc

[StefanKarpinski]

There's a clever trick that we could use to create large zero matrices really fast: mmap the file /dev/zero. This is, in fact, exactly what this "file" exists for. The benefit of doing this are:

1. It's nearly instantaneous since no memory actually needs to be allocated or filled with zeros until it's accessed.
2. You can read and write the memory exactly as you normally would: the kernel only allocates memory pages for you when you do something with them.

Since a fair amount of the time, no one actually touches most of the memory in a zeros array, this might be a big win. On the other hand, the drawbacks are:

1. Trade obvious immediate allocation cost for unobvious delayed allocation cost.
2. Can run out of memory on read/write instead of only on allocate.
3. Doesn't work for anything but zeros(), e.g. for ones().

[ViralBShah]

The thing is that we use Array() as the default constructor almost everywhere now, and zeros is not used nearly as much.

Wouldn't it be better if we can handle the pagefaults ourselves, which will take care of all cases that call fill()?

[StefanKarpinski]

That could be possible, but testing with an mmap of /dev/zero might be an easy way to find out what there is to gain.

[ViralBShah]

It will definitely lead to better cache behaviour, and there will be a certain pattern of usage where this will be greatly beneficial for sure.

-viral

On Jul 18, 2011, at 11:23 AM, StefanKarpinski wrote:

That could be possible, but testing with an mmap of /dev/zero might be an easy way to find out what there is to gain.

Reply to this email directly or view it on GitHub:
#130 (comment)

[ViralBShah]

See:

http://stackoverflow.com/questions/2688466/why-mallocmemset-slower-than-calloc

[ViralBShah]

It is quite possible that this does not give any observable gains for anything except very large matrices. Is it possible to quickly do an experiment to see if this gives any measurable benefits? Also, we do not use zeros() much in our codebase.

[StefanKarpinski]

Yeah, this is a cool idea, but the way our memory allocation works via a memory pool, it's not very practical. Let's close for now.

[StefanKarpinski]

This is a real performance issue that I've seen in the wild recently and has come up on the mailing list:

https://groups.google.com/forum/#!topic/julia-users/aW4rjUIFq6w

I'm fairly certain that NumPy is using the mmap /dev/zero trick and we should too.

[stevengj]

Why not just use calloc? See also #9147.

[ViralBShah]

calloc does seem like the easiest first thing to try.

[quinnj]

It'd be worth bench-marking Anonymous Mmaps too, since they're now fully supported and "easy" :)

julia> m = Mmap.mmap(Vector{Float64}, 10000)
10000-element Array{Float64,1}:
 0.0
 0.0
 0.0

[StefanKarpinski]

Why not just use calloc?

Yes, excellent point, @stevengj. That's definitely the first thing to do.