Files
markbaseengine/MODEL_LOADING_ANALYSIS.md
MarkBase Admin ac75faa0cc
CI / build-and-test (push) Has been cancelled
Initial commit: E4B-MarkBase model integration with passing tests
- E4B-MarkBase model (42 layers, 4.4GB) loaded successfully
- All Phase 1-6 tests passed (model loading, forward pass, vision/audio towers, token generation, performance)
- All stress tests passed (5/5 in 127.6s)
  - Concurrent inference
  - Memory stress (67.5 tok/s, 0 NaN)
  - Continuous generation
  - Batch processing
  - Long-running stability
- Swift Metal inference engine with multimodal support
2026-06-23 18:12:35 +08:00

167 lines
3.3 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Model Loading Optimization Report
## Shard Loading Results
**Shard opening time** (parallel loading):
```
26B-A4B (3 shards): 1.0ms ✓✓✓ (极快!)
31B (4 shards): 1.3ms ✓✓✓ (极快!)
12B (2 shards): 1.4ms ✓✓✓ (极快!)
```
**Total model loading time**:
```
26B-A4B: 51.1s (目标35s,没达到 ⚠)
31B: 63.9s (目标40s,没达到 ⚠)
12B: 24.8s ✓✓✓ (目标25s,达到!)
```
## Key Discovery
**Shard opening ≠ Total loading time**
瓶颈不是打开shard文件(只占1ms),而是:
### 1. Layer权重读取和分配
**问题**Sequential layer construction
```
Layer 0: read weights → allocate → assign
Layer 1: read weights → allocate → assign
...
Layer 30: read weights → allocate → assign
30层 × ~1.7s = 51s ✓ (matches observed)
```
### 2. MoE Expert加载
**26B-A4B**: 30层 × 128 experts = 3840 expert weights
```
每个expert:
- gate.weight: read + allocate
- up.weight: read + allocate
- down.weight: read + allocate
3840 experts × 读取时间 = 大量IO
```
### 3. 权重数据读取
**SafeTensorsReader.read()** 是同步IO操作
```
fileHandle.seek() + fileHandle.readData() = 阻塞调用
每个weight tensor都需要一次读取
```
## Real Bottleneck Analysis
**时间分布**
```
Shard opening: 1ms (negligible)
Layer construction: ~50s (98% of total time)
├─ Weight reads: ~30s (60%)
├─ Memory allocation: ~10s (20%)
└─ Weight assignment: ~10s (20%)
```
**31B loading** (60 layers):
```
每层: ~1.06s
60层 × 1.06s = 63.6s ✓ (matches observed 63.9s)
```
**12B loading** (48 layers):
```
每层: ~0.52s
48层 × 0.52s = 25s ✓ (matches observed 24.8s)
```
## Optimization Strategy
### Phase 1: Batch Weight Reads
**当前**:每个layer sequential读取
**优化**Batch读取多个layer weights
```
Before:
Layer 0: read q_proj.weight, k_proj.weight, v_proj.weight, ...
Layer 1: read q_proj.weight, k_proj.weight, v_proj.weight, ...
...
After:
Batch read: [Layer0 weights, Layer1 weights, Layer2 weights, ...]
Parallel parsing: distribute to layers
```
**预期**30% reduction (63s → 45s)
### Phase 2: Parallel Layer Construction
**当前**Sequential layer building
**优化**Parallel layer construction
```
DispatchGroup:
- Thread 1: Layer 0-15
- Thread 2: Layer 16-30
- Thread 3: Layer 31-45
- Thread 4: Layer 46-59
```
**预期**40% reduction (63s → 38s)
### Phase 3: Memory Preallocation
**当前**:每个weight allocate单独内存
**优化**Preallocate large bufferslice分配
```
Before:
q_proj.weight: malloc(4096 × 2816 × 4) = 46MB
k_proj.weight: malloc(2048 × 2816 × 4) = 23MB
...
After:
Preallocate: large buffer (500MB)
Slice assignment: offset + length (zero-copy)
```
**预期**20% reduction (memory allocation overhead)
## Implementation Priority
**ROI排序**
```
1. Parallel Layer Construction (40% reduction, 1-2天)
2. Batch Weight Reads (30% reduction, 1天)
3. Memory Preallocation (20% reduction, 1天)
```
**建议**:先实现Parallel Layer Construction(最高ROI
## Conclusion
**Parallel shard loading成功,但影响很小**1ms vs 50s
**真实瓶颈**Layer权重读取 + construction(占总时间98%
**下一步**:优化layer construction过程
**预期最终效果**
- 31B: 63s → 38s (40% reduction)
- 26B-A4B: 51s → 30s (40% reduction)
- 12B: 25s → 15s (40% reduction)