zophos

← Notes · 08-邊讀邊截斷:串流,不先把全部讀進記憶體.md

邊讀邊截斷:串流,不先把全部讀進記憶體

截斷不該等資料到齊

截斷之前,全文已經在記憶體裡

第 3 版 把截斷函式自己的中繼狀態壓到 O(1)。但函式拿到的 text,是前面的 I/O 先完整讀進來的,默認了全文已存進記憶體。

問題不在截斷寫得好不好,在截斷的時機。 資料到齊才截斷,就注定要先裝得下全部。


把截斷搬進讀取

可接受代價:耦合使截斷不再是純函式

前三版是先讀完、再呼叫截斷函式 truncate_head / truncate_tail;現在讀取與截斷合在一起當做一件事——每讀進一塊就決定留不留,做法開始受工具(呼叫端)影響:

read bash
截斷函式 truncate_head truncate_tail
要留的部分 開頭 50 KB 結尾 50 KB
來源 檔案 process 的 stdout / stderr
讀到一半能不能停 能:不讀,檔案也不會怎樣 不能:pipe 塞滿,child 會卡住
做法 讀到上限就停 讀到底,但只留最後 50 KB
耦合度 讀檔和截斷在同一個函式裡 collect:I/O(讀 pipe、解碼、發出輸出事件)
ModelTail:給模型的那份(最後 50 KB 的 byte 環),每個事件都餵一份進去

read:讀到上限再多一個 byte

// Read::call
tokio::task::spawn_blocking(move || {
    let file = std::fs::File::open(&path)?;
    let file_bytes = file.metadata()?.len();
    read_head(file, file_bytes)
})
.await?
fn read_head(reader: impl std::io::Read, file_bytes: u64) -> anyhow::Result<String> {
    let mut kept = Vec::with_capacity(file_bytes.min(MAX_OUTPUT_BYTES as u64 + 1) as usize + 128); // 128:留給截斷提示
    reader.take(MAX_OUTPUT_BYTES as u64 + 1).read_to_end(&mut kept)?;
    // 截斷
    // kept.len()= MAX_OUTPUT_BYTES + 1 byte
    if kept.len() > MAX_OUTPUT_BYTES {
        kept.truncate(MAX_OUTPUT_BYTES);
        let mut text = decode_lossy(kept);
        write!(text, "\n\n[truncated: showing first {MAX_OUTPUT_BYTES} bytes").unwrap();
        if file_bytes > MAX_OUTPUT_BYTES as u64 {
            write!(text, " - file is {file_bytes} bytes total").unwrap();
        }
        text.push(']');
        return Ok(text);
    }
    //沒截斷
    Ok(decode_lossy(kept))
}

整個函式的關鍵是那個 + 1。

  • take(n) 讀滿 n 個 byte 就回報 EOF。
  • 多讀的那一個 byte,回答「後面還有沒有」。 讀得到第 MAX + 1 個,就是有截斷;回傳前切回 MAX。
  • 用 std::fs,不用 tokio::fs。 tokio::fs::File 底下也是在背景 thread 跑阻塞的 std::fs,但 open、stat、read 各跑一趟,而且先讀進它自己的 buffer、再複製給呼叫端——同時有兩份 50 KB。整段放進一個 spawn_blocking,read_to_end 直接寫進 kept:只跑一趟、只有一份。read_head 也因此變成同步函式。
  • 提示直接寫進原字串,不 format! 一個新的。 format! 會另配一個字串、把 50 KB 再複製一份,兩份同時活著;預留 128 bytes 給提示(最長約 85 bytes),write! 直接寫在 text 後面,連提示本身的暫存字串都不用。

同一個 115 MB 的檔案:峰值 115 MB → 52 KB,68 ms → 約 0.04 ms。快一千多倍,因為根本沒讀那 115 MB。峰值就是 kept 那 50 KB 本身;1 KB 的檔案峰值 1.5 KB。

bash:讀到底,只留尾巴

stdout 是一條 pipe,作業系統只替它留一塊固定大小的緩衝(Linux 通常 64 KB)。讀的一端停下來,緩衝一滿,child 下一次寫就被卡住——永遠寫不完、永遠不結束,工具永遠等不到 exit code。所以 bash 一定要讀到 EOF。

輸入則反過來:child 不該碰到 Zophos 的終端機。stdin 給 /dev/null,再用 setsid 開一個沒有終端機的新 session——要輸入的命令(read、sudo 的密碼提示)會立刻失敗,而不是被 SIGTTIN 暫停、讓整個回合卡住。為什麼兩樣都要、原本的寫法卡在哪裡,見 bash 與終端機。

stdout 和 stderr 合成同一條 pipe(2>&1,像終端機把兩者放在同一個裝置上):讀取端每讀一塊、解碼一次,成為一個輸出事件。CLI 即時顯示原樣,TUI 只顯示模型拿到的那份;模型那份交給 ModelTail——一個只留最後 50 KB 的 byte 環。為什麼合成一條而不是分兩條讀、ModelTail 為什麼只是個 byte 環,見 兩條 pipe 沒有共同的時間線;事件怎麼設計、UTF-8 怎麼接、兩種投影怎麼一致,見 一串事件,兩種投影。

ModelTail 跟 I/O 分開:保留結尾要一直讀到最後,中間維護一個不斷覆寫的 byte 環和總數——抽成不碰 I/O 的元件,才能直接餵文字測試,讀取那頭只管讀。

給模型的結果長這樣:

[truncated: showing last 51200 of 38888896 bytes]

4999998
4999999
5000000
exit code: 0

上限只剩 bytes

前三版有兩個上限:2000 行、50 KB。如果窗口是 VecDeque<String>,行數上限是有用的——50 KB 只算文字,但每一行還要一個 24 bytes 的 String 標頭和一次配置,短行時固定開銷遠大於文字。

byte 環裡沒有行,這個理由就消失了。 輸出是給模型讀的,不是給人捲動的,總大小才是要限制的量——而且算的是模型實際讀到的文字。

留下的缺口是 bytes 只近似 token:很短的行(seq、ls -1)每個 byte 花的 token 比一般文字多,每個換行至少一個。這種輸出真的開始擠占 context,再加 token 估算。


切在 byte 上的代價

以 byte 為單位,補上了逐行讀取的兩個洞:一行再長,read 也停在 50 KB、bash 也只留最後 50 KB;超長的單行會留下它的結尾,不再整行消失。

換來幾個邊緣上的瑕疵:

  • read 可能切在字元中間、只剩半行。 截斷點落在多位元組字元裡時,lossy 解碼會在結尾留下一個 �;最後一行也可能被切開。
  • bash 給模型的開頭可能是半行。 byte 環從前面淘汰時是按 byte 切的,可能切在一個字元或一行的中間(ModelTail 只跳過開頭殘缺的那幾個 byte,避免第一個字是亂碼)。
  • 畫面和模型的差別只在範圍。 畫面即時顯示每一塊,模型拿最後 50 KB;兩者都來自同一串事件、不經重排,只是投影的範圍不同(見 一串事件,兩種投影)。

都不影響正確性,只是邊緣是殘缺的。

(v4 的 bash 還有 timeout、取消、process group——那是另一個題目。)


欣賞 Rust 之美

Drop 就是關閉

read_head 回傳,take 包著的 File 跟著 drop,檔案就關了;bash 被取消時,讀取那個 future 被 drop,ReaderStream 和底下的 pipe 一起釋放。擁有權在哪裡結束,資源就在哪裡釋放——沒有 close() 要記得寫。


總結

  1. 截斷的時機比截斷的寫法重要。 資料到齊才截斷,就要先裝得下全部;第 4 版把截斷搬進讀取。

  2. 能停的就停,不能停的就只留尾巴。 檔案讀到上限再多一個 byte 就停——那一個 byte 回答「後面還有沒有」,不信任 stat;process 一定要讀到 EOF,否則 pipe 塞滿卡死 child,所以讀到底、只留最後 50 KB。

  3. 資料結構換了,上限的理由也跟著換。 行數上限只對 VecDeque<String> 這種每行有固定開銷的結構有意義;窗口裡沒有行,它就沒有存在的理由,50 KB 算的是模型實際讀到的文字。