atmos/os_lib/web_engine/

fetch_limit.rs

//! リソース取得の同時実行を**種別横断で**制御する。
//!
//! 仕様は `spec/resource_loading.md`（実装順序の 4「キューを 1 本に統合し、
//! 種別ごとの優先度を持たせる」に相当する最小実装）。
//!
//! # なぜ要るのか
//!
//! 【2026-08-05】フォントと画像でワーカー上限を**別々に**持っていたため、
//! 実際には最大 8 本が同時に TLS 接続を張っていた。
//! この自作 TCP/TLS スタックは同時接続に弱いことが既知で
//! （`spec/TODO.md` の「接続回数依存の劣化」）、
//! CSS/JS も非同期化したところ**メイン HTML が読み込めなくなった**
//! （`[NET][STATS] total=3`、正常時は 13）。
//!
//! 上限は種別ごとではなく**全体で**持たないと意味がない。
//! さらに、メイン HTML はページの他の何よりも優先される
//! （それが無ければ描くものが無い）。
//!
//! # 方針
//!
//! - 同時に走るリソース取得ワーカーの総数に上限を設ける
//! - メイン HTML の取得中はリソース取得を新たに始めない
//!
//! グローバル状態を持つが、判定そのものは純粋関数へ切り出してあり
//! 単体試験で固定してある（`tests/src/test_fetch_limit.rs`）。

use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering};

/// 同時に走らせるリソース取得ワーカーの総数上限。
///
/// 【2026-08-05】最初 4 にしたが**背景写真が届かなくなった**
/// （`[NET][STATS] total=12`、`[IMGPERF]` が出ない。正常時は 13）。
/// 3.7MB の画像は最も重く、並列度を半分にすると 200 秒に間に合わない。
///
/// 観測された不具合の原因は「同時数が 8 だから」ではなく
/// **メイン HTML と競合したから**だった（`set_main_load_in_flight` を参照）。
/// そちらだけを直し、総数は現状（フォント 4 + 画像 4）を維持する。
/// ここは種別ごとの上限を横断で押さえる**安全網**として置く。
///
/// 増減させるときは `[NET][STATS]` の total と `[IMGPERF]` の有無で
/// 必ず実測すること。同時接続に弱いスタックなので上げるのも危険。
pub const MAX_TOTAL_FETCH_WORKERS: usize = 8;

/// 現在走っているリソース取得ワーカーの総数。
static ACTIVE: AtomicUsize = AtomicUsize::new(0);

/// メイン HTML を取得中か。
static MAIN_LOAD_IN_FLIGHT: AtomicBool = AtomicBool::new(false);

/// リソースの種別。値が小さいほど優先。
///
/// 【2026-08-05】CSS を非同期取得にしたとき、CSS がフォント 8 本・画像と
/// 同じ枠を奪い合って**到着が遅すぎ**、スタイル付きのレイアウトが
/// 実行時間内に始まらなかった（ログの行番号で確認。
/// 「カスケード開始 ルール数=2403」の後に完了行が出ない）。
///
/// CSS はレイアウトに必須なので最優先。
/// フォントは文字の見た目に直結するので次。
/// 画像は無くても文章が読める。JS は最後。
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Kind {
    /// スタイルシート。レイアウトに必須。
    Style = 0,
    /// Web フォント。
    Font = 1,
    /// 画像。
    Image = 2,
    /// スクリプト。
    Script = 3,
}

impl Kind {
    pub fn priority(self) -> u8 {
        self as u8
    }
}

/// 優先度の高い順に取り出すべき添字を返す（純粋関数）。
///
/// 同じ優先度なら**先に積まれた方**を選ぶ（先入れ先出し）。
/// 空なら `None`。
///
/// 計算量: **O(N)**。キューは高々数十件なので十分。
pub fn pick_highest_priority(prios: &[u8]) -> Option<usize> {
    let mut best: Option<usize> = None;
    for (i, &p) in prios.iter().enumerate() {
        match best {
            None => best = Some(i),
            Some(b) => {
                if p < prios[b] {
                    best = Some(i);
                }
            }
        }
    }
    best
}

/// 低優先のワーカーを起こしてよいか（純粋関数）。
///
/// より優先度の高いリソースが待っている間は起こさない。
/// これが無いと、CSS が画像 4 本の後ろに並んで到着が遅れる。
pub fn may_spawn_lower(
    main_in_flight: bool,
    active: usize,
    queued: usize,
    higher_priority_pending: usize,
) -> bool {
    if higher_priority_pending > 0 {
        return false;
    }
    may_spawn(main_in_flight, active, queued)
}

/// 新しいワーカーを起こしてよいかの判定（純粋関数）。
///
/// - `main_in_flight` … メイン HTML の取得中か
/// - `active` … 現在走っているワーカー総数
/// - `queued` … そのキューに溜まっている件数
///
/// メイン HTML 取得中は新規に起こさない。
/// 上限に達していても起こさない。
/// 積むものが無ければ起こさない。
pub fn may_spawn(main_in_flight: bool, active: usize, queued: usize) -> bool {
    if main_in_flight {
        return false;
    }
    if active >= MAX_TOTAL_FETCH_WORKERS {
        return false;
    }
    queued > 0
}

/// メイン HTML の取得開始／終了を記録する。
pub fn set_main_load_in_flight(v: bool) {
    MAIN_LOAD_IN_FLIGHT.store(v, Ordering::Release);
}

pub fn main_load_in_flight() -> bool {
    MAIN_LOAD_IN_FLIGHT.load(Ordering::Acquire)
}

/// 保留中・実行中の <script> があるか（`WebEngine::run_pending_scripts`。2026-10-05）。
/// 最初の画面の後にスクリプトを回すようにしたので、待機状態の表示ではこれも「読込中」に数える。
static SCRIPTS_PENDING: AtomicBool = AtomicBool::new(false);

pub fn set_scripts_pending(v: bool) {
    SCRIPTS_PENDING.store(v, Ordering::Release);
}

/// 現在のワーカー総数。
pub fn active() -> usize {
    ACTIVE.load(Ordering::Acquire)
}

/// ワーカーを 1 本起こしてよいか判定し、よければ枠を確保する。
///
/// 確保できたら `true`。呼び出し側は**必ず** `release()` と対にすること。
pub fn try_acquire(queued: usize) -> bool {
    if !may_spawn(main_load_in_flight(), active(), queued) {
        return false;
    }
    ACTIVE.fetch_add(1, Ordering::AcqRel);
    true
}

/// ワーカーの枠を返す。
pub fn release() {
    // 0 を下回らせない（二重解放しても壊さない）。
    let _ = ACTIVE.fetch_update(Ordering::AcqRel, Ordering::Acquire, |v| {
        Some(v.saturating_sub(1))
    });
}

// ───────────── パニックしたワーカーの後始末 ─────────────
//
// 【2026-08-25 バグ修正】ワーカーがパニックすると
// `#[panic_handler]` が `scheduler::exit()` を呼んでその場で殺す。
// 巻き戻しが無いので `release()` は**実行されない**。
//
// これは机上の話ではない。`os_lib/webp` は
// 「カーネルの panic 禁止ポリシーの**対象外**」と明記された
// ベンダリング済みデコーダで、まさにこのワーカーの中で回る。
// 壊れた WebP が 8 枚あれば枠を全部食い潰し、以後
// **フォントも画像も二度と読み込まれない**（黙って止まる）。
//
// パニックハンドラの中でロックを取ってはいけない。
// そのロックを握ったまま死んだ場合に、回収そのものが固まる。
// だから所有者の記録は**原子変数の配列**にし、
// 実際の後始末は毎フレーム走る `pump()` に任せる。

/// 枠の所有者 PID。0 は空き。
static OWNER_PID: [AtomicUsize; MAX_TOTAL_FETCH_WORKERS] =
    [const { AtomicUsize::new(0) }; MAX_TOTAL_FETCH_WORKERS];

/// 死んだフォントワーカーの数（`font_queue::pump` が回収する）。
pub static FONT_WORKERS_DIED: AtomicUsize = AtomicUsize::new(0);
/// 死んだ画像ワーカーの数（`image::pump` が回収する）。
pub static IMAGE_WORKERS_DIED: AtomicUsize = AtomicUsize::new(0);

/// 種別: フォントワーカー。
pub const KIND_FONT: usize = 1;
/// 種別: 画像ワーカー。
pub const KIND_IMAGE: usize = 2;

/// 所有者の記録。`pid` の下位ビットに種別を混ぜず、別配列で持つ。
static OWNER_KIND: [AtomicUsize; MAX_TOTAL_FETCH_WORKERS] =
    [const { AtomicUsize::new(0) }; MAX_TOTAL_FETCH_WORKERS];

/// ワーカーが自分の PID で枠の所有を宣言する。
///
/// 枠自体は親（`pump`）が `try_acquire` で確保済み。
/// ここで結び付けておかないと、死んだときに誰の枠か分からない。
pub fn claim(pid: usize, kind: usize) {
    if pid == 0 {
        return;
    }
    for i in 0..MAX_TOTAL_FETCH_WORKERS {
        if OWNER_PID[i]
            .compare_exchange(0, pid, Ordering::AcqRel, Ordering::Acquire)
            .is_ok()
        {
            OWNER_KIND[i].store(kind, Ordering::Release);
            return;
        }
    }
}

/// 正常終了時に所有を外す（`release()` と対で呼ぶ）。
pub fn unclaim(pid: usize) {
    if pid == 0 {
        return;
    }
    for i in 0..MAX_TOTAL_FETCH_WORKERS {
        if OWNER_PID[i]
            .compare_exchange(pid, 0, Ordering::AcqRel, Ordering::Acquire)
            .is_ok()
        {
            OWNER_KIND[i].store(0, Ordering::Release);
            return;
        }
    }
}

/// パニックハンドラから呼ぶ。**ロックを取らない**。
///
/// `pid` が枠を持っていたら解放し、種別ごとの死亡数を 1 増やす。
/// 種別の数え上げは `pump()` が `active_workers` の補正に使う。
pub fn on_process_died(pid: usize) {
    if pid == 0 {
        return;
    }
    for i in 0..MAX_TOTAL_FETCH_WORKERS {
        if OWNER_PID[i].load(Ordering::Acquire) != pid {
            continue;
        }
        let kind = OWNER_KIND[i].swap(0, Ordering::AcqRel);
        OWNER_PID[i].store(0, Ordering::Release);
        release();
        match kind {
            KIND_FONT => {
                FONT_WORKERS_DIED.fetch_add(1, Ordering::AcqRel);
            }
            KIND_IMAGE => {
                IMAGE_WORKERS_DIED.fetch_add(1, Ordering::AcqRel);
            }
            _ => {}
        }
        return;
    }
}

/// 死んだフォントワーカー数を取り出して 0 に戻す。
pub fn take_font_deaths() -> usize {
    FONT_WORKERS_DIED.swap(0, Ordering::AcqRel)
}

/// 死んだ画像ワーカー数を取り出して 0 に戻す。
pub fn take_image_deaths() -> usize {
    IMAGE_WORKERS_DIED.swap(0, Ordering::AcqRel)
}

/// ブラウザの `draw()` がどの段にいるか。
///
/// 【なぜ必要か】停滞時、`draw()` から戻ってこないことまでは分かったが
/// **どこで戻らないか**が分からない。提示ループ（`[IDLE]` を出す側）は
/// 停滞中も動き続けるので、そちらから覗ける場所に段を置く。
/// 0=描画外 1=入口 2=フォント取り込み 3=再レイアウト 4=描画 5=出口直前
pub static DRAW_STAGE: AtomicUsize = AtomicUsize::new(0);

pub fn set_draw_stage(s: usize) {
    DRAW_STAGE.store(s, Ordering::Relaxed);
}

/// 取得の待機状態を 1 行で出す。
///
/// 【2026-08-25】撮影時期を決めるための**明示的な待機状態**。
///
/// 採取スクリプトはこれまでログの断片から「もう終わったか」を
/// 推し量っていた（`after-resp total=` が伸びない、`resolved=` と
/// `SUCCESS` の対応を数える等）。どれも外れた。接続を使い回すと
/// `resolved=` は出ないし、数 MB の転送中は何も出ない。
/// まだ取得中なのに「静止した」と判断して撮っていた。
///
/// 当てるのをやめ、**OS が自分の状態を明示する**。
/// 全部ゼロなら取得は残っていない。
///
/// **呼び出し元は止まらないループであること。**
/// 最初はブラウザの `draw()` から出していたが、待機に入ると
/// `draw()` 自体が止まるため、最後の行が古い標本のまま残り
/// 「まだ取得中」に見え続けた。画面の提示ループから呼ぶ。
pub fn idle_line() {
    crate::warn!(
        "[IDLE] font_pending={} img_pending={} active={} main={} fw={} iw={} ff={} 描画段={}",
        super::font_queue::pending_len(),
        super::image::pending_count(),
        active(),
        main_load_in_flight() || SCRIPTS_PENDING.load(Ordering::Acquire),
        // 種別ごとの稼働本数。全体の枠に余裕があっても種別の上限に
        // 達していれば起こせないので、止まったとき内訳が要る。
        super::font_queue::worker_count(),
        super::image::worker_count(),
        // 取得の中に居るフォントワーカー数。停止点の切り分けに使う。
        super::font_queue::in_fetch_count(),
        // `draw()` がどこで止まっているか。
        DRAW_STAGE.load(Ordering::Relaxed),
    );
}