Làm cách nào để bỏ qua bộ nhớ cache của hệ thống tệp khi đọc tệp ở Golang?

Question

Giả sử rằng nội dung của tệp Foo.txt như sau.

Foo Bar Bar Foo 

Hãy xem chương trình ngắn sau đây.

package main 

import "syscall" 
import "fmt" 


func main() { 
    fd, err := syscall.Open("Foo.txt", syscall.O_RDONLY, 0) 
    if err != nil { 
     fmt.Println("Failed on open: ", err) 
    } 
    data := make([]byte, 100) 
    _, err = syscall.Read(fd, data) 
    if err != nil { 
     fmt.Println("Failed on read: ", err) 
    } 
    syscall.Close(fd) 
} 

Khi chúng tôi chạy chương trình trên, chúng tôi không gặp lỗi nào, đó là hành vi đúng.

Bây giờ, tôi sửa đổi dòng syscall.Open thành các dòng sau.

fd, err := syscall.Open("Foo.txt", syscall.O_RDONLY | syscall.O_SYNC | syscall.O_DIRECT, 0) 

Khi tôi chạy lại chương trình, tôi nhận được kết quả sau (không mong muốn).

Failed on read: invalid argument 

Làm thế nào tôi có thể một cách chính xác thông qua các cờ syscall.O_SYNC và syscall.O_DIRECT theo quy định của các open man page cho bỏ qua bộ nhớ cache hệ thống tập tin?

Lưu ý rằng tôi đang sử dụng giao diện syscall tập tin trực tiếp thay vì giao diện os tập tin bởi vì tôi không thể tìm thấy một cách để vượt qua những lá cờ vào các chức năng được cung cấp bởi os, nhưng tôi mở cửa cho các giải pháp sử dụng os với điều kiện chúng hoạt động chính xác để tắt bộ nhớ cache của hệ thống tệp trên lần đọc.

Cũng lưu ý rằng tôi đang chạy trên Ubuntu 14.04 với ext4 làm hệ thống tệp của tôi.

---

Cập nhật: Tôi cố gắng để sử dụng gói @Nick Craig-Wood trong các mã dưới đây.

package main 

import "io" 
import "github.com/ncw/directio" 
import "os" 
import "fmt" 


func main() { 
    in, err := directio.OpenFile("Foo.txt", os.O_RDONLY, 0666) 
    if err != nil { 
     fmt.Println("Error on open: ", err) 
    } 

    block := directio.AlignedBlock(directio.BlockSize) 
    _, err = io.ReadFull(in, block) 
    if err != nil { 
     fmt.Println("Error on read: ", err) 
    } 
} 

Đầu ra là sau

Error on read: unexpected EOF 

Answer 1

Từ trang open man, dưới GHI CHÚ:

Cờ O_DIRECT thể áp đặt các hạn chế liên kết vào độ dài và địa chỉ của người sử dụng không gian bộ đệm và độ lệch tập tin của I/O. Trong các hạn chế liên kết Linux khác nhau tùy theo hệ thống tập tin và phiên bản hạt nhân và có thể vắng mặt hoàn toàn.

Vì vậy, bạn có thể có vấn đề căn chỉnh, hoặc bộ nhớ hoặc bù đắp tệp hoặc kích thước bộ đệm của bạn có thể là "sai". Điều chỉnh và kích thước nên là không rõ ràng. Trang người dùng tiếp tục:

Tuy nhiên hiện không có giao diện độc lập cho hệ thống tệp để phát hiện những hạn chế này đối với tệp hoặc hệ thống tệp nhất định.

Và ngay cả Linus nặng, theo cách kín đáo thường thấy của mình:

"Điều đó luôn luôn quấy rầy tôi về O_DIRECT là toàn bộ giao diện chỉ là ngu ngốc, và có lẽ được thiết kế bởi một loạn trí khỉ trên một số chất kiểm soát tâm trí nghiêm trọng. " —Linus

Chúc may mắn!

p.s. Đâm trong bóng tối: tại sao không đọc 512 byte?

Answer 2

Bạn có thể sử dụng số directio package mà tôi đã thực hiện cho mục đích này chính xác.

Từ trang web

Đây là thư viện cho ngôn ngữ Go để cho phép sử dụng trực tiếp IO dưới tất cả các hệ điều hành hỗ trợ của Go (trừ OpenBSD và plan9).

IO trực tiếp thực hiện IO đến và từ đĩa mà không cần đệm dữ liệu trong hệ điều hành. Nó rất hữu ích khi bạn đang đọc hoặc viết nhiều dữ liệu mà bạn không muốn lấp đầy bộ nhớ cache của hệ điều hành.

Xem ở đây cho tài liệu gói

http://go.pkgdoc.org/github.com/ncw/directio

Answer 3

bạn có thể thử sử dụng fadvice và madvice, nhưng không có đảm bảo. cả hai sẽ hoạt động nhiều hơn với các tệp/dữ liệu lớn hơn, vì:

Một phần cố tình giữ gìn bộ nhớ cần thiết hơn là loại bỏ bộ nhớ không cần thiết.

xem mã nguồn Linux, điều gì sẽ làm điều gì đó và nội dung nào không. Ví dụ POSIX_FADV_NOREUSE không làm gì cả.

http://lxr.free-electrons.com/source/mm/fadvise.c#L62

http://lxr.free-electrons.com/source/mm/madvise.c

package main 

import "fmt" 
import "os" 
import "syscall" 

import "golang.org/x/sys/unix" 

func main() { 
    advise := false 
    if len(os.Args) > 1 && os.Args[1] == "-x" { 
     fmt.Println("setting file advise") 
     advise =true 
    } 

    data := make([]byte, 100) 
    handler, err := os.Open("Foo.txt") 
    if err != nil { 
     fmt.Println("Failed on open: ", err) 
    }; defer handler.Close() 

    if advise { 
     unix.Fadvise(int(handler.Fd()), 0, 0, 4) // 4 == POSIX_FADV_DONTNEED 
    } 

    read, err := handler.Read(data) 
    if err != nil { 
     fmt.Println("Failed on read: ", err) 
     os.Exit(1) 
    } 

    if advise { 
     syscall.Madvise(data, 4) // 4 == MADV_DONTNEED 
    } 

    fmt.Printf("read %v bytes\n", read) 
} 

/usr/bin/lần -v ./direct -x

Command being timed: "./direct -x" 
User time (seconds): 0.00 
System time (seconds): 0.00 
Percent of CPU this job got: 0% 
Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.03 
Average shared text size (kbytes): 0 
Average unshared data size (kbytes): 0 
Average stack size (kbytes): 0 
Average total size (kbytes): 0 
Maximum resident set size (kbytes): 1832 
Average resident set size (kbytes): 0 
Major (requiring I/O) page faults: 2 
Minor (reclaiming a frame) page faults: 149 
Voluntary context switches: 2 
Involuntary context switches: 2 
Swaps: 0 
File system inputs: 200 
File system outputs: 0 
Socket messages sent: 0 
Socket messages received: 0 
Signals delivered: 0 
Page size (bytes): 4096 
Exit status: 0