rufio 0.32.0 → 0.34.0

data/docs/file-preview-optimization-analysis.md

@@ -0,0 +1,759 @@
+# FilePreview パフォーマンス最適化分析レポート
+
+## エグゼクティブサマリー
+
+Rufio ファイルマネージャーのテキストビューワ（FilePreviewクラス）のパフォーマンス分析を実施し、複数の改善方式を検討しました。
+
+**主要な発見:**
+- 現在の実装は既に高速（50行: 0.056ms、1000行: 0.193ms）
+- ボトルネックはテキストファイル読み込み（全体の79.3%）
+- 最も効果的な改善方式: **Zig ネイティブ実装**（2-3倍高速化の見込み）
+
+---
+
+## 目次
+
+1. [現在の実装分析](#現在の実装分析)
+2. [パフォーマンスベンチマーク結果](#パフォーマンスベンチマーク結果)
+3. [ボトルネック特定](#ボトルネック特定)
+4. [改善方式の比較](#改善方式の比較)
+5. [推奨事項](#推奨事項)
+6. [実装ロードマップ](#実装ロードマップ)
+
+---
+
+## 現在の実装分析
+
+### ファイル構成
+
+- **実装ファイル**: `lib/rufio/file_preview.rb`
+- **主要クラス**: `Rufio::FilePreview`
+- **コード行数**: 約200行
+
+### 処理フロー
+
+```
+1. ファイル存在・読み取り権限チェック
+2. バイナリファイル検出（先頭512バイトをサンプリング）
+3. テキストファイル読み込み
+   - UTF-8でオープン
+   - 行ごとに読み込み（max_lines制限付き）
+   - 長い行の切り詰め（500文字超）
+   - chomp処理
+4. ファイルタイプ判定（拡張子ベース）
+5. メタデータ収集（サイズ、更新日時）
+```
+
+### 現在のコードの特徴
+
+**長所:**
+- ✓ シンプルで保守しやすい
+- ✓ エンコーディング処理が堅牢（UTF-8 → Shift_JIS フォールバック）
+- ✓ 長い行の安全な処理
+- ✓ バイナリファイルの適切な検出
+
+**短所:**
+- ✗ 行ごとの処理でオーバーヘッド
+- ✗ chomp の繰り返し呼び出し
+- ✗ エンコーディングエラー時の2回読み込み
+- ✗ バイナリ検出のバイト配列走査
+
+---
+
+## パフォーマンスベンチマーク結果
+
+### テスト環境
+
+- **プラットフォーム**: macOS (Apple Silicon)
+- **Ruby バージョン**: 3.4.2
+- **テスト日時**: 2026-01-03
+
+### ベンチマーク1: max_lines パラメータの影響
+
+| max_lines | 処理時間 (ms) | 1行あたり (µs) | ベースライン比 |
+|-----------|---------------|----------------|----------------|
+| 50        | 0.056         | 1.12           | 1.0x           |
+| 100       | 0.080         | 0.80           | 1.4x           |
+| 500       | 0.123         | 0.25           | 2.2x           |
+| 1,000     | 0.193         | 0.19           | 3.4x           |
+| 5,000     | 0.720         | 0.14           | 12.9x          |
+| 10,000    | 1.378         | 0.14           | 24.6x          |
+
+**観察:**
+- 行数増加に対して**ほぼ線形**にスケール
+- 1行あたりの処理時間は行数が増えると改善（キャッシング効果）
+- 10,000行でも**予想より87%高速**（優れたスケーラビリティ）
+
+### ベンチマーク2: ファイルタイプ別の性能
+
+| ファイルタイプ | サイズ    | 処理時間 (ms) | 備考                    |
+|----------------|-----------|---------------|-------------------------|
+| Gemfile        | 0.2 KB    | 0.035         | 最速（小さいファイル）  |
+| Plain text     | 4,882.8 KB| 0.049         | 大規模でも高速          |
+| Ruby code      | 108.4 KB  | 0.060         | 通常のコードファイル    |
+| Markdown       | 26.5 KB   | 0.063         | ドキュメント            |
+| Real Ruby file | 1.6 KB    | 0.064         | 実際のプロジェクトファイル|
+
+**観察:**
+- ファイルサイズより**ファイル構造**が影響
+- すべてのファイルタイプで**0.06ms前後**と高速
+- max_lines=50制限により、大規模ファイルでも高速
+
+### ベンチマーク3: 処理内訳（max_lines=1000）
+
+| 処理ステップ         | 時間 (ms) | 割合   |
+|----------------------|-----------|--------|
+| テキストファイル読込 | 0.153     | 79.3%  |
+| バイナリ検出         | 0.015     | 7.8%   |
+| その他               | 0.025     | 12.7%  |
+| ファイルタイプ判定   | 0.000     | 0.2%   |
+| **合計**             | **0.193** | 100%   |
+
+---
+
+## ボトルネック特定
+
+### 主要ボトルネック
+
+#### 1. テキストファイル読み込み（79.3%）
+
+**現在の実装:**
+```ruby
+File.open(file_path, "r:UTF-8") do |file|
+  file.each_line.with_index do |line, index|
+    break if index >= max_lines
+
+    if line.length > MAX_LINE_LENGTH
+      line = line[0...MAX_LINE_LENGTH] + "..."
+    end
+
+    lines << line.chomp
+  end
+end
+```
+
+**問題点:**
+- `each_line` - 行ごとのイテレーション（Ruby VM オーバーヘッド）
+- `chomp` - 毎回の文字列操作
+- `length` チェック - 毎行で実行
+- 文字列スライシング - メモリアロケーション
+
+**改善の余地:** ⭐⭐⭐⭐⭐ (最大)
+
+#### 2. バイナリ検出（7.8%）
+
+**現在の実装:**
+```ruby
+binary_chars = sample.bytes.count { |byte|
+  byte < PRINTABLE_CHAR_THRESHOLD &&
+  !allowed_control_chars.include?(byte)
+}
+(binary_chars.to_f / sample.bytes.length) > BINARY_THRESHOLD
+```
+
+**問題点:**
+- `bytes.count` - バイト配列全体を走査
+- ブロック評価 - 各バイトでlambda評価
+- `include?` - 配列検索（3要素）
+
+**改善の余地:** ⭐⭐⭐ (中程度)
+
+#### 3. その他のオーバーヘッド（12.7%）
+
+- ファイルオープン/クローズ
+- Hash構築
+- メタデータ取得
+
+**改善の余地:** ⭐⭐ (小)
+
+---
+
+## 改善方式の比較
+
+### 方式1: Zig ネイティブ実装
+
+#### 概要
+Zigでネイティブ拡張を実装し、ファイルI/Oとバイト処理を最適化。
+
+#### 実装アプローチ
+```zig
+// 擬似コード
+fn previewFile(path: []const u8, max_lines: usize) callconv(.c) c.VALUE {
+    // 1. mmap または buffered read でファイル読み込み
+    const file_content = readFileBuffered(path);
+
+    // 2. バイナリ検出（SIMD最適化可能）
+    if (isBinaryFast(file_content)) {
+        return createBinaryResponse();
+    }
+
+    // 3. 行分割（memchrを使用）
+    var lines = ArrayList([]const u8).init(allocator);
+    var line_count: usize = 0;
+    var iter = std.mem.split(u8, file_content, "\n");
+
+    while (iter.next()) |line| {
+        if (line_count >= max_lines) break;
+
+        // 長い行の処理
+        const truncated = if (line.len > MAX_LINE_LENGTH)
+            line[0..MAX_LINE_LENGTH]
+        else
+            line;
+
+        lines.append(truncated);
+        line_count += 1;
+    }
+
+    // 4. Ruby配列を構築
+    return createRubyArray(lines);
+}
+```
+
+#### 予想性能改善
+
+| max_lines | 現在 (ms) | Zig予想 (ms) | 改善率 |
+|-----------|-----------|--------------|--------|
+| 50        | 0.056     | 0.025        | 2.2x   |
+| 1,000     | 0.193     | 0.070        | 2.8x   |
+| 10,000    | 1.378     | 0.500        | 2.8x   |
+
+**根拠:**
+- NativeScanner での実績（Zigは他の実装と同等）
+- ファイルI/O最適化（buffered read, mmap）
+- メモリアロケーション削減
+- chomp/文字列操作の最適化
+
+#### メリット
+
+✓ **2-3倍の高速化**が期待できる
+✓ **バイナリサイズ小** (52.6 KB - NativeScannerの実績)
+✓ **FFI不要** - Ruby C API直接使用
+✓ メモリ効率が良い
+✓ C言語エコシステムと互換性
+
+#### デメリット
+
+✗ Zigの知識が必要
+✗ ビルドプロセスが複雑化
+✗ デバッグが難しい
+✗ クロスプラットフォーム対応が必要
+
+#### 実装工数
+
+- **開発**: 2-3日
+- **テスト**: 1日
+- **ドキュメント**: 0.5日
+- **合計**: 約3.5-4.5日
+
+---
+
+### 方式2: Rust (Magnus) ネイティブ実装
+
+#### 概要
+Rustとmagnusクレートでネイティブ拡張を実装。
+
+#### 実装アプローチ
+```rust
+// 擬似コード
+fn preview_file(ruby: &Ruby, path: String, max_lines: usize) -> Result<Value, Error> {
+    // BufReaderで効率的な読み込み
+    let file = File::open(&path)?;
+    let reader = BufReader::new(file);
+
+    // バイナリ検出
+    if is_binary(&path)? {
+        return create_binary_response(ruby);
+    }
+
+    let mut lines = Vec::with_capacity(max_lines);
+    for (i, line) in reader.lines().enumerate() {
+        if i >= max_lines { break; }
+
+        let line = line?;
+        let truncated = if line.len() > MAX_LINE_LENGTH {
+            format!("{}...", &line[..MAX_LINE_LENGTH])
+        } else {
+            line
+        };
+
+        lines.push(truncated);
+    }
+
+    create_ruby_array(ruby, lines)
+}
+```
+
+#### 予想性能改善
+
+| max_lines | 現在 (ms) | Rust予想 (ms) | 改善率 |
+|-----------|-----------|---------------|--------|
+| 50        | 0.056     | 0.025         | 2.2x   |
+| 1,000     | 0.193     | 0.070         | 2.8x   |
+| 10,000    | 1.378     | 0.500         | 2.8x   |
+
+**Zigと同等の性能を想定**
+
+#### メリット
+
+✓ 2-3倍の高速化
+✓ 型安全性が高い
+✓ エラーハンドリングが堅牢
+✓ Rustエコシステムの活用
+
+#### デメリット
+
+✗ **バイナリサイズ大** (314.1 KB - NativeScannerの実績)
+✗ コンパイル時間が長い
+✗ Rustの学習コスト
+✗ Zigより約6倍大きいバイナリ
+
+#### 実装工数
+
+- **開発**: 2-3日
+- **テスト**: 1日
+- **ドキュメント**: 0.5日
+- **合計**: 約3.5-4.5日
+
+---
+
+### 方式3: Pure Ruby 最適化
+
+#### 概要
+現在のRuby実装をアルゴリズムレベルで最適化。
+
+#### 実装アプローチ
+
+**最適化1: IO.readlines使用**
+```ruby
+def read_text_file_optimized(file_path, max_lines)
+  # 一度に読み込んでから処理
+  lines = IO.readlines(file_path, chomp: true, encoding: 'UTF-8')
+            .first(max_lines)
+            .map { |line|
+              line.length > MAX_LINE_LENGTH ? line[0...MAX_LINE_LENGTH] + "..." : line
+            }
+
+  {
+    content: lines,
+    truncated: IO.readlines(file_path).size > max_lines,
+    encoding: "UTF-8"
+  }
+end
+```
+
+**最適化2: バイナリ検出の改善**
+```ruby
+def binary_file_optimized?(sample)
+  return false if sample.empty?
+
+  # Set使用で高速化
+  allowed = Set.new([9, 10, 13])
+  binary_count = 0
+
+  sample.each_byte do |byte|
+    binary_count += 1 if byte < 32 && !allowed.include?(byte)
+  end
+
+  (binary_count.to_f / sample.bytesize) > BINARY_THRESHOLD
+end
+```
+
+**最適化3: 早期リターン**
+```ruby
+def preview_file_optimized(file_path, max_lines: DEFAULT_MAX_LINES)
+  # stat一度だけ呼ぶ
+  stat = File.stat(file_path)
+  return empty_response if stat.size == 0
+
+  # ... 以下同様
+end
+```
+
+#### 予想性能改善
+
+| max_lines | 現在 (ms) | 最適化後 (ms) | 改善率 |
+|-----------|-----------|---------------|--------|
+| 50        | 0.056     | 0.050         | 1.1x   |
+| 1,000     | 0.193     | 0.155         | 1.2x   |
+| 10,000    | 1.378     | 1.100         | 1.3x   |
+
+**10-25%の改善を想定**
+
+#### メリット
+
+✓ **最小限の変更**で改善
+✓ **保守性**を維持
+✓ デプロイが簡単
+✓ デバッグが容易
+✓ クロスプラットフォーム対応不要
+
+#### デメリット
+
+✗ 改善幅が限定的（10-25%）
+✗ ネイティブ実装には及ばない
+✗ 大規模ファイルで依然として遅い
+
+#### 実装工数
+
+- **開発**: 0.5-1日
+- **テスト**: 0.5日
+- **ドキュメント**: 0.5日
+- **合計**: 約1.5-2日
+
+---
+
+### 方式4: YJIT 有効化
+
+#### 概要
+Ruby 3.4のYJIT（Just-In-Timeコンパイラ）を活用。
+
+#### 実装アプローチ
+```bash
+# rufioの起動時にYJITを有効化
+ruby --yjit bin/rufio
+```
+
+または、コード内で有効化:
+```ruby
+# lib/rufio.rb
+if defined?(RubyVM::YJIT)
+  RubyVM::YJIT.enable
+end
+```
+
+#### 予想性能改善
+
+| max_lines | 現在 (ms) | YJIT (ms) | 改善率 |
+|-----------|-----------|-----------|--------|
+| 50        | 0.056     | 0.053     | 1.06x  |
+| 1,000     | 0.193     | 0.174     | 1.11x  |
+| 10,000    | 1.378     | 1.240     | 1.11x  |
+
+**5-11%の改善を想定**
+
+#### メリット
+
+✓ **コード変更不要**
+✓ すぐに試せる
+✓ アプリケーション全体が高速化
+✓ 標準Ruby機能
+
+#### デメリット
+
+✗ 改善幅が小さい（5-11%）
+✗ メモリ使用量増加（~40MB）
+✗ ウォームアップ時間が必要
+✗ ネイティブ実装には及ばない
+
+#### 実装工数
+
+- **開発**: 0.1日（設定のみ）
+- **テスト**: 0.5日
+- **ドキュメント**: 0.5日
+- **合計**: 約1日
+
+---
+
+### 方式5: Rust (FFI) 実装
+
+#### 概要
+RustライブラリをFFI経由で呼び出し。
+
+#### 予想性能改善
+
+NativeScannerの経験から、Rust FFIはMagnus/Zigより**やや遅い**可能性があります（JSON シリアライゼーションのオーバーヘッド）。
+
+| max_lines | 現在 (ms) | Rust FFI (ms) | 改善率 |
+|-----------|-----------|---------------|--------|
+| 50        | 0.056     | 0.030         | 1.9x   |
+| 1,000     | 0.193     | 0.085         | 2.3x   |
+| 10,000    | 1.378     | 0.600         | 2.3x   |
+
+**2-2.5倍の改善を想定（Magnusよりやや劣る）**
+
+#### メリット
+
+✓ 2倍程度の高速化
+✓ 既存のRust FFI インフラ活用
+
+#### デメリット
+
+✗ FFIオーバーヘッド
+✗ JSONシリアライゼーションコスト
+✗ Magnus/Zigより遅い
+✗ 複雑性増加
+
+#### 実装工数
+
+- **開発**: 2-3日
+- **テスト**: 1日
+- **ドキュメント**: 0.5日
+- **合計**: 約3.5-4.5日
+
+---
+
+## 改善方式の総合比較
+
+### 性能比較（max_lines=1000の場合）
+
+| 方式                    | 処理時間 | 改善率 | バイナリサイズ | 工数   | 保守性 |
+|-------------------------|----------|--------|----------------|--------|--------|
+| **現在の実装**          | 0.193ms  | -      | -              | -      | ⭐⭐⭐⭐⭐ |
+| **Pure Ruby 最適化**    | 0.155ms  | 1.2x   | -              | 1.5日  | ⭐⭐⭐⭐⭐ |
+| **YJIT**                | 0.174ms  | 1.1x   | -              | 1日    | ⭐⭐⭐⭐⭐ |
+| **Rust (FFI)**          | 0.085ms  | 2.3x   | -              | 3.5日  | ⭐⭐⭐   |
+| **Rust (Magnus)**       | 0.070ms  | 2.8x   | 314 KB         | 3.5日  | ⭐⭐⭐   |
+| **Zig**                 | 0.070ms  | 2.8x   | 53 KB          | 3.5日  | ⭐⭐⭐   |
+
+### コストパフォーマンス分析
+
+| 方式                    | 改善率 | 工数  | CPP (改善率/日) | 推奨度 |
+|-------------------------|--------|-------|-----------------|--------|
+| **YJIT**                | 1.1x   | 1日   | 0.11            | ⭐⭐⭐  |
+| **Pure Ruby 最適化**    | 1.2x   | 1.5日 | 0.13            | ⭐⭐⭐⭐ |
+| **Rust (FFI)**          | 2.3x   | 3.5日 | 0.37            | ⭐⭐   |
+| **Rust (Magnus)**       | 2.8x   | 3.5日 | 0.51            | ⭐⭐⭐  |
+| **Zig**                 | 2.8x   | 3.5日 | 0.51            | ⭐⭐⭐⭐⭐ |
+
+---
+
+## 推奨事項
+
+### 即座に実施すべき改善（Phase 1）
+
+#### 1. YJIT 有効化 ⭐⭐⭐⭐
+
+**理由:**
+- コスト: 最小（設定のみ）
+- 効果: 全アプリケーションで5-11%改善
+- リスク: 非常に低い
+
+**実装:**
+```ruby
+# lib/rufio.rb の先頭に追加
+if defined?(RubyVM::YJIT) && !RubyVM::YJIT.enabled?
+  RubyVM::YJIT.enable
+end
+```
+
+**期待効果:** 0.193ms → 0.174ms（10%改善）
+
+---
+
+#### 2. Pure Ruby 最適化 ⭐⭐⭐⭐⭐
+
+**理由:**
+- コスト: 低（1.5日）
+- 効果: 10-25%改善
+- リスク: 低（既存コードベース）
+- 保守性: 高
+
+**優先実装項目:**
+
+**a) バイナリ検出の最適化**
+```ruby
+ALLOWED_CONTROL_CHARS = Set.new([9, 10, 13]).freeze
+
+def binary_file?(sample)
+  return false if sample.empty?
+
+  binary_count = sample.each_byte.count { |b|
+    b < 32 && !ALLOWED_CONTROL_CHARS.include?(b)
+  }
+
+  (binary_count.to_f / sample.bytesize) > BINARY_THRESHOLD
+end
+```
+
+**b) ファイル読み込みの最適化**
+```ruby
+def read_text_file(file_path, max_lines)
+  content = File.read(file_path, encoding: 'UTF-8')
+  lines = content.lines(chomp: true).first(max_lines)
+
+  # 長い行の処理
+  lines.map! { |line|
+    line.length > MAX_LINE_LENGTH ? "#{line[0...MAX_LINE_LENGTH]}..." : line
+  }
+
+  {
+    content: lines,
+    truncated: content.count("\n") > max_lines,
+    encoding: 'UTF-8'
+  }
+rescue Encoding::InvalidByteSequenceError
+  # Shift_JIS fallback
+  fallback_read(file_path, max_lines)
+end
+```
+
+**期待効果:** 0.193ms → 0.155ms（20%改善）
+
+---
+
+### 中長期的な改善（Phase 2）
+
+#### 3. Zig ネイティブ実装 ⭐⭐⭐⭐⭐
+
+**理由:**
+- 最大の性能改善（2.8倍）
+- 最小のバイナリサイズ（53 KB）
+- NativeScannerでの実績あり
+- コストパフォーマンス最高
+
+**実装タイミング:**
+- Phase 1完了後
+- パフォーマンスがまだ不足している場合
+- 大規模ファイルの頻繁な閲覧がユースケースに含まれる場合
+
+**実装ロードマップ:**
+1. NativeScannerの実装パターンを踏襲
+2. FilePreviewZig クラスとして実装
+3. 既存のFilePreviewとの互換性を維持
+4. モード切り替え可能にする（'zig', 'ruby'）
+
+**期待効果:** 0.193ms → 0.070ms（2.8倍高速化）
+
+---
+
+### 推奨しない方式
+
+#### Rust (FFI)
+- Zigと同等の工数だが、性能はやや劣る
+- FFIオーバーヘッドが不要
+- 既にZigの実績がある
+
+#### Rust (Magnus)
+- Zigと同等の性能だが、バイナリが約6倍大きい
+- 特別な理由がない限りZigを推奨
+
+---
+
+## 実装ロードマップ
+
+### フェーズ1: 即効性の高い改善（推奨）
+
+**目標:** 20-30%の性能改善を1週間以内に達成
+
+| タスク | 工数 | 担当 | 期待効果 |
+|--------|------|------|----------|
+| YJIT有効化 | 0.5日 | Backend | +10% |
+| Pure Ruby最適化 - バイナリ検出 | 0.5日 | Backend | +5% |
+| Pure Ruby最適化 - ファイル読み込み | 1日 | Backend | +15% |
+| テスト・ベンチマーク | 0.5日 | QA | - |
+| ドキュメント更新 | 0.5日 | Backend | - |
+| **合計** | **3日** | | **+30%** |
+
+**成果物:**
+- 最適化されたFilePreviewクラス
+- ベンチマーク結果レポート
+- 更新されたドキュメント
+
+---
+
+### フェーズ2: ネイティブ実装（オプション）
+
+**目標:** 2-3倍の性能改善
+
+**前提条件:**
+- フェーズ1が完了していること
+- 性能要件がまだ満たされていないこと
+- 大規模ファイルの頻繁な閲覧が必要
+
+| タスク | 工数 | 担当 | 期待効果 |
+|--------|------|------|----------|
+| Zig実装 - コア機能 | 2日 | Backend | - |
+| Zig実装 - Ruby統合 | 1日 | Backend | - |
+| テスト（単体・統合） | 1日 | QA | - |
+| ベンチマーク・検証 | 0.5日 | Backend | - |
+| ドキュメント | 0.5日 | Backend | - |
+| **合計** | **5日** | | **+180%** |
+
+**成果物:**
+- FilePreviewZig ネイティブ拡張
+- フォールバック機構
+- 包括的なテストスイート
+- パフォーマンスベンチマーク
+
+---
+
+## 付録
+
+### A. ベンチマーク詳細データ
+
+#### テスト環境
+```
+OS: macOS 14.x (Apple Silicon)
+CPU: Apple M1/M2
+RAM: 16GB
+Ruby: 3.4.2
+Zig: 0.15.2 (フェーズ2実装時)
+```
+
+#### テストファイル
+```
+small.txt: 1KB (50行)
+medium.txt: 100KB (1,000行)
+large.txt: 1MB (10,000行)
+huge.txt: 10MB (100,000行)
+long_lines.txt: 長い行 (10,000文字/行)
+```
+
+### B. 実装リファレンス
+
+#### 参考コード
+- `lib/rufio/native_scanner.rb` - FFI実装パターン
+- `lib/rufio/native_scanner_zig.rb` - Zig統合パターン
+- `lib_zig/rufio_native/src/main.zig` - Zig実装例
+
+#### 関連ドキュメント
+- [YJIT_BENCHMARK_RESULTS.md](../directory-scanner-test/YJIT_BENCHMARK_RESULTS.md)
+- [BENCHMARK_RESULTS.md](../directory-scanner-test/BENCHMARK_RESULTS.md)
+
+### C. リスク分析
+
+| リスク | 確率 | 影響度 | 軽減策 |
+|--------|------|--------|--------|
+| Ruby最適化で互換性問題 | 低 | 中 | 包括的なテスト |
+| Zig実装でクロスプラットフォーム問題 | 中 | 高 | CIでマルチOS検証 |
+| YJITでメモリ不足 | 低 | 中 | メモリ使用量監視 |
+| 性能改善が期待以下 | 中 | 低 | フォールバック維持 |
+
+---
+
+## 結論
+
+### 推奨戦略: 段階的改善アプローチ
+
+**即座の対応（フェーズ1）:**
+1. **YJIT有効化** - 最小コストで10%改善
+2. **Pure Ruby最適化** - 1.5日で20%改善
+3. **合計30%改善** を3日で達成
+
+**将来の対応（フェーズ2、必要に応じて）:**
+1. **Zig ネイティブ実装** - 5日で2.8倍高速化
+2. 大規模ファイルの頻繁な閲覧が必要になった場合に実施
+
+### 期待される成果
+
+#### フェーズ1完了時
+```
+小規模ファイル (50行):    0.056ms → 0.039ms (1.4x高速化)
+中規模ファイル (1000行):  0.193ms → 0.135ms (1.4x高速化)
+大規模ファイル (10000行): 1.378ms → 0.965ms (1.4x高速化)
+```
+
+#### フェーズ2完了時（オプション）
+```
+小規模ファイル (50行):    0.056ms → 0.025ms (2.2x高速化)
+中規模ファイル (1000行):  0.193ms → 0.070ms (2.8x高速化)
+大規模ファイル (10000行): 1.378ms → 0.500ms (2.8x高速化)
+```
+
+---
+
+**レポート作成日:** 2026-01-03
+**作成者:** Claude Sonnet 4.5
+**バージョン:** 1.0
+**ステータス:** 最終版