File size: 2,677 Bytes
e59bd9d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
"""Execution policy: PERFORMANCE | BALANCED | EFFICIENCY.

A policy is a set of decision thresholds, not marketing words. Every knob
below has a consumer in the scheduler/monitor and changes real behavior:

- probe_iterations: how many real micro-benchmark iterations run when
  choosing a strategy / precision.
- strategy aggressiveness: PERFORMANCE may test model_parallel for large
  models; EFFICIENCY never leaves single-GPU unless VRAM forces it.
- monitoring frequency: PERFORMANCE samples GPU state less often during
  training (less overhead); EFFICIENCY idles at the slowest safe rate.
"""

from __future__ import annotations

from dataclasses import dataclass
from enum import Enum
from typing import Dict


class PerformanceMode(str, Enum):
    PERFORMANCE = "performance"
    BALANCED = "balanced"
    EFFICIENCY = "efficiency"


@dataclass(frozen=True)
class Policy:
    mode: PerformanceMode
    probe_iterations: int
    model_parallel_min_param_mb: float   # below this, model split is refused
    allow_strategy_probe: bool           # measure DP vs single at startup
    monitor_active_seconds: float
    monitor_idle_seconds: float
    min_dp_batch_per_gpu: int            # DP pointless below this per-GPU batch
    allow_ddp_auto: bool                 # DDP may win a probe and be selected


POLICIES: Dict[PerformanceMode, Policy] = {
    PerformanceMode.PERFORMANCE: Policy(
        mode=PerformanceMode.PERFORMANCE,
        probe_iterations=12,
        model_parallel_min_param_mb=200.0,
        allow_strategy_probe=True,
        monitor_active_seconds=1.0,
        monitor_idle_seconds=5.0,
        min_dp_batch_per_gpu=2,
        allow_ddp_auto=False,  # Windows gloo reliability: opt-in only, always
    ),
    PerformanceMode.BALANCED: Policy(
        mode=PerformanceMode.BALANCED,
        probe_iterations=6,
        model_parallel_min_param_mb=400.0,
        allow_strategy_probe=True,
        monitor_active_seconds=2.0,
        monitor_idle_seconds=10.0,
        min_dp_batch_per_gpu=4,
        allow_ddp_auto=False,
    ),
    PerformanceMode.EFFICIENCY: Policy(
        mode=PerformanceMode.EFFICIENCY,
        probe_iterations=0,   # no probing overhead at all
        model_parallel_min_param_mb=1e9,
        allow_strategy_probe=False,
        monitor_active_seconds=5.0,
        monitor_idle_seconds=30.0,
        min_dp_batch_per_gpu=8,
        allow_ddp_auto=False,
    ),
}


def get_policy(mode: str) -> Policy:
    try:
        return POLICIES[PerformanceMode(str(mode).lower())]
    except KeyError:
        raise ValueError(
            f"unknown performance mode {mode!r}; valid: {[m.value for m in PerformanceMode]}"
        )