README

This work is based on mmap-go written by edsrzf using BSD-style license.

On top of the original repository, I made these bug fixes:

  • Incorrect syscall parameters in Unix msync
  • Panic if buffer size is too large in Windows

The modifications I made are subject to BSD-style license; for details, please read LICENSE.

Expand ▾ Collapse ▴

Documentation

Overview

    Package mmap allows mapping files into memory. It tries to provide a simple, reasonably portable interface, but doesn't go out of its way to abstract away every little platform detail. This specifically means:

    * forked processes may or may not inherit mappings
    * a file's timestamp may or may not be updated by writes through mappings
    * specifying a size larger than the file's actual size can increase the file's size
    * If the mapped file is being modified by another process while your program's running, don't expect consistent results between platforms
    

    Index

    Constants

    View Source
    const (
    	// RDONLY maps the memory read-only.
    	// Attempts to write to the MMap object will result in undefined behavior.
    	RDONLY = 0
    	// RDWR maps the memory as read-write. Writes to the MMap object will update the
    	// underlying file.
    	RDWR = 1 << iota
    	// COPY maps the memory as copy-on-write. Writes to the MMap object will affect
    	// memory, but the underlying file will remain unchanged.
    	COPY
    	// If EXEC is set, the mapped memory is marked as executable.
    	EXEC
    )
    View Source
    const (
    	// If the ANON flag is set, the mapped memory will not be backed by a file.
    	ANON = 1 << iota
    )
    View Source
    const (
    	MAP_ANONYMOUS = syscall.MAP_ANONYMOUS
    )

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type MMap

    type MMap []byte

      MMap represents a file mapped into memory.

      func Map

      func Map(f *os.File, prot, flags int) (MMap, error)

        Map maps an entire file into memory. Note that because of runtime limitations, no file larger than about 2GB can be completely mapped into memory. If ANON is set in flags, f is ignored.

        func MapRegion

        func MapRegion(f *os.File, length int, prot, flags int, offset int64) (MMap, error)

          MapRegion maps part of a file into memory. The offset parameter must be a multiple of the system's page size. If length is 0, the entire file will be mapped. Note that because of runtime limitations, no file larger than about 2GB can be completely mapped into memory. If ANON is set in flags, f is ignored.

          func (MMap) Flush

          func (m MMap) Flush() error

            Flush synchronizes the mapping's contents to the file's contents on disk.

            func (MMap) Lock

            func (m MMap) Lock() error

              Lock keeps the mapped region in physical memory, ensuring that it will not be swapped out.

              func (MMap) Unlock

              func (m MMap) Unlock() error

                Unlock reverses the effect of Lock, allowing the mapped region to potentially be swapped out. If m is already unlocked, aan error will result.

                func (*MMap) Unmap

                func (m *MMap) Unmap() error

                  Unmap deletes the memory mapped region, flushes any remaining changes, and sets m to nil. Trying to read or write any remaining references to m after Unmap is called will result in undefined behavior. Unmap should only be called on the slice value that was originally returned from a call to Map. Calling Unmap on a derived slice may cause errors.