Yes, I have done some experiments for reading .npz big files (~ 2 GB) playing with the chunksize, and here are my results:

```
==> 16KB.out <==
       44.85 real        13.34 user         5.21 sys
==> 64K.out <==
       33.93 real         9.11 user         3.78 sys
==> 128KB.out <==
       31.46 real         8.43 user         3.63 sys
==> 256KB.out <==
       29.26 real         8.12 user         3.66 sys
==> 512KB.out <==
       29.98 real         8.80 user         3.73 sys
==> 1MB.out <==
       31.66 real         8.74 user         3.87 sys
==> 256MB.out <==
       47.68 real         9.02 user         6.20 sys
```

So I'd say that Chuck is right, and that a chunksize of 256KB (i.e. `max_buffer_size` = 2**18) gives the better read speed overall.  My hardware is a MacBook Air with OSX, 4 GB RAM and SSD disk.

BTW, peak memory consumption for the process is very similar in all cases (~ 1 GB RSIZE).  During the benchmarks, I have never deleted the filesystem cache, so the times are probably I/O from memory. Anyway, here it is the script that I used:

```
import numpy as np
import os
from time import time

def test_big_arrays():
    t0 = time()
    tmp = 'test.npz'
    # Uncomment the line below the first time you run this
    # print "Before saving"
    # L = (1 << 31) + 1e5
    # a = np.empty(L, dtype=np.uint8)
    # np.savez(tmp, a=a)
    # print "After saving", round(time()-t0, 3)
    # del a
    print "Before loading", round(time()-t0, 3)
    npfile = np.load(tmp)
    a = npfile['a']
    npfile.close()
    print "After loading", round(time()-t0, 3)
    #os.remove(tmp)

from memory_profiler import memory_usage
mem_usage = memory_usage((test_big_arrays,), interval=1, timeout=1)
print(mem_usage)
```