Пример #1
0
// Lock loads all memory pages in physical memory. This can take a long time for
// larger files but access to these memory locations will be faster.
func (m *Map) Lock() (err error) {
	if err := syscall.Mlock(m.Data); err != nil {
		return err
	}

	return nil
}
Пример #2
0
func main() {
	flag.Parse()
	allocationSize := *allocationInGB * GB

	log.Printf("Allocating 0x%X bytes\n", allocationSize)
	memory := make([]byte, allocationSize)

	// mlock prevents memory from being swapped to disk
	err := syscall.Mlock(memory)
	if err != nil {
		log.Fatalln("Error locking memory.", err)
	}

	var value byte

	for {
		log.Printf("Writing 0x%X to 0x%X bytes.\n", value, allocationSize)
		for i, _ := range memory {
			memory[i] = value
		}
		log.Printf("Verifying %x written to %x bytes.\n", value, allocationSize)
		for i, v := range memory {
			if v != value {
				log.Printf("Found unexpected byte value 0x%X at position %d.\n", v, i)
			}
		}
		value++
	}
}
Пример #3
0
// Lock locks a region of the mapped shared memory
func (buf *sharedBuffer) Lock(offset, length int) error {
	b := buf.Bytes()
	err := checkOffsetLength(b, offset, length)
	if err == nil {
		err = syscall.Mlock(b[offset : offset+length])
	}
	return os.NewSyscallError("shm: mlock", err)
}
Пример #4
0
func mmapFile(fileName string) (*mmapData, error) {
	file, err := os.Open(fileName)
	if err != nil {
		return nil, err
	}

	stat, err := file.Stat()
	if err != nil {
		file.Close()
		return nil, err
	}

	size := stat.Size()
	pageAlignedSize := (size + 4095) &^ 4095
	data, err := syscall.Mmap(int(file.Fd()), 0, int(pageAlignedSize),
		syscall.PROT_READ, syscall.MAP_PRIVATE)

	if err != nil {
		file.Close()
		return nil, err
	}

	err = syscall.Mlock(data)
	if err != nil {
		syscall.Munmap(data)
		file.Close()
		return nil, err
	}

	md := &mmapData{file, data[:size]}
	runtime.SetFinalizer(md, func(m *mmapData) {
		syscall.Munlock(m.d)
		syscall.Munmap(m.d)
		m.f.Close()
	})

	return md, nil
}
Пример #5
0
// Lock implements Map.Lock().
func (m *mmap) Lock() error {
	return syscall.Mlock(m.data)
}
Пример #6
0
// Prevent the mmap from being paged to the swap area.
func (m Mmap) Lock() error {
	return syscall.Mlock(m)
}