Memory-mapped I/O

    Create an -like object for creating zeroed-out mmapped-memory that is not tied to a file for use in . Used by SharedArray for creating shared memory arrays.

    Examples

    1. julia> using Mmap
    3. julia> anon = Mmap.Anonymous();
    5. julia> isreadable(anon)
    6. true
    8. julia> iswritable(anon)
    9. true
    11. julia> isopen(anon)
    12. true

    Mmap.mmap — Function

    Create an Array whose values are linked to a file, using memory-mapping. This provides a convenient way of working with data too large to fit in the computer’s memory.

    The type is an Array{T,N} with a bits-type element of T and dimension N that determines how the bytes of the array are interpreted. Note that the file must be stored in binary format, and no format conversions are possible (this is a limitation of operating systems, not Julia).

    The file is passed via the stream argument, either as an open or filename string. When you initialize the stream, use "r" for a “read-only” array, and "w+" to create a new array used to write values to disk.

    If no type argument is specified, the default is Vector{UInt8}.

    Optionally, you can specify an offset (in bytes) if, for example, you want to skip over a header in the file. The default value for the offset is the current stream position for an IOStream.

    The grow keyword argument specifies whether the disk file should be grown to accommodate the requested size of array (if the total file size is < requested array size). Write privileges are required to grow the file.

    The keyword argument specifies whether the resulting Array and changes made to it will be visible to other processes mapping the same file.

    1. # Create a file for mmapping
    2. # (you could alternatively use mmap to do this step, too)
    3. using Mmap
    4. A = rand(1:20, 5, 30)
    5. s = open("/tmp/mmap.bin", "w+")
    6. write(s, size(A,1))
    7. write(s, size(A,2))
    8. # Now write the data
    9. write(s, A)
    10. close(s)
    12. # Test by reading it back in
    13. s = open("/tmp/mmap.bin")   # default is read-only
    14. m = read(s, Int)
    15. n = read(s, Int)
    16. A2 = mmap(s, Matrix{Int}, (m,n))

    creates a m-by-n Matrix{Int}, linked to the file associated with stream s.

    A more portable file would need to encode the word size – 32 bit or 64 bit – and endianness information in the header. In practice, consider encoding binary data using standard formats like HDF5 (which can be used with memory-mapping).

    Create a BitArray whose values are linked to a file, using memory-mapping; it has the same purpose, works in the same way, and has the same arguments, as , but the byte representation is different.

    Examples

    1. julia> using Mmap
    5. julia> B = mmap(io, BitArray, (25,30000));
    8. julia> Mmap.sync!(B);
    10. julia> close(io);
    12. julia> io = open("mmap.bin", "r+");
    14. julia> C = mmap(io, BitArray, (25,30000));
    16. julia> C[3, 4000]
    17. true
    19. julia> C[2, 4000]
    20. false
    22. julia> close(io)

    This creates a 25-by-30000 BitArray, linked to the file associated with stream io.

    Forces synchronization between the in-memory version of a memory-mapped or BitArray and the on-disk version.