Coverage for tests/simulator/test_multirequests_derive.py: 100%

1import sys 

2import os 

3 

4# Add current path so test-package imports resolve correctly. 

5sys.path.append(os.getcwd()) 

6 

7from tests.test_utils import assert_equal_dict 

8from tests.test_utils import temp_sys_path 

9 

10with temp_sys_path("simulator", "streamwise"): 

11 from sim_types import GPUType 

12 from sim_types import Model 

13 from sim_types import QualityLevel 

14 

15 from multirequests import TIME_PER_REQ 

16 from multirequests import INIT_REPLICAS 

17 from multirequests import TIME_PER_REQ_ADAPTIVE 

18 from multirequests import INIT_REPLICAS_ADAPTIVE 

19 

20 

21def test_init_replicas_snapshot() -> None: 

22 """Pin INIT_REPLICAS to known-good values so silent drift is detected.""" 

23 expected = { 

24 GPUType.A100: { 

25 Model.GEMMA: 8, 

26 Model.FLUX: 8, 

27 Model.HF_VAE: 7, 

28 Model.FT: 192, 

29 Model.UPSCALER: 40, 

30 Model.OTHERS: 1, 

31 }, 

32 GPUType.H100: { 

33 Model.HF: 14, 

34 Model.HF_VAE: 4, 

35 Model.FT: 38, 

36 Model.UPSCALER: 8, 

37 }, 

38 } 

39 assert_equal_dict(INIT_REPLICAS, expected, name="INIT_REPLICAS") 

40 

41 

42def test_time_per_req_snapshot() -> None: 

43 """Pin TIME_PER_REQ to known-good values so silent drift is detected.""" 

44 expected = { 

45 GPUType.A100: { 

46 Model.GEMMA: 8.57, 

47 Model.FLUX: 1.65, 

48 Model.HF_VAE: 21.80, 

49 Model.FT: 246.97, 

50 Model.UPSCALER: 49.40, 

51 Model.OTHERS: 25.80, 

52 }, 

53 GPUType.H100: { 

54 Model.HF: 56.96, 

55 Model.HF_VAE: 21.80, 

56 Model.FT: 250.70, 

57 Model.UPSCALER: 49.40, 

58 }, 

59 } 

60 assert_equal_dict(TIME_PER_REQ, expected, name="TIME_PER_REQ") 

61 

62 

63def test_init_replicas_adaptive_snapshot() -> None: 

64 """Pin INIT_REPLICAS_ADAPTIVE to known-good values so silent drift is detected.""" 

65 expected = { 

66 GPUType.A100: { 

67 Model.GEMMA: 8, 

68 Model.FLUX: 8, 

69 Model.HF_VAE: 7, 

70 Model.FT: 192, 

71 Model.UPSCALER: 40, 

72 Model.OTHERS: 1, 

73 }, 

74 GPUType.H100: { 

75 Model.HF: 14, 

76 Model.HF_VAE: 4, 

77 Model.FT: 38, 

78 Model.UPSCALER: 8, 

79 }, 

80 } 

81 assert_equal_dict(INIT_REPLICAS_ADAPTIVE, expected, name="INIT_REPLICAS_ADAPTIVE") 

82 

83 

84def test_time_per_req_adaptive_snapshot() -> None: 

85 """Pin TIME_PER_REQ_ADAPTIVE to known-good values so silent drift is detected.""" 

86 expected = { 

87 GPUType.A100: { 

88 Model.GEMMA: { 

89 QualityLevel.HIGH: 8.57, 

90 QualityLevel.MEDIUM: 8.57, 

91 QualityLevel.LOW: 8.57, 

92 }, 

93 Model.FLUX: { 

94 QualityLevel.HIGH: 1.65, 

95 QualityLevel.MEDIUM: 0.41, 

96 QualityLevel.LOW: 0.10, 

97 }, 

98 Model.HF_VAE: { 

99 QualityLevel.HIGH: 21.80, 

100 QualityLevel.MEDIUM: 2.79, 

101 QualityLevel.LOW: 1.25, 

102 }, 

103 Model.FT: { 

104 QualityLevel.HIGH: 246.97, 

105 QualityLevel.MEDIUM: 57.57, 

106 QualityLevel.LOW: 22.99, 

107 }, 

108 Model.UPSCALER: { 

109 QualityLevel.HIGH: 49.40, 

110 QualityLevel.MEDIUM: 8.50, 

111 QualityLevel.LOW: 3.50, 

112 }, 

113 Model.OTHERS: { 

114 QualityLevel.HIGH: 25.80, 

115 QualityLevel.MEDIUM: 25.80, 

116 QualityLevel.LOW: 25.80, 

117 }, 

118 }, 

119 GPUType.H100: { 

120 Model.HF: { 

121 QualityLevel.HIGH: 56.96, 

122 QualityLevel.MEDIUM: 9.96, 

123 QualityLevel.LOW: 4.26, 

124 }, 

125 Model.HF_VAE: { 

126 QualityLevel.HIGH: 21.80, 

127 QualityLevel.MEDIUM: 2.79, 

128 QualityLevel.LOW: 1.25, 

129 }, 

130 Model.FT: { 

131 QualityLevel.HIGH: 250.70, 

132 QualityLevel.MEDIUM: 57.41, 

133 QualityLevel.LOW: 23.14, 

134 }, 

135 Model.UPSCALER: { 

136 QualityLevel.HIGH: 49.40, 

137 QualityLevel.MEDIUM: 8.52, 

138 QualityLevel.LOW: 3.50, 

139 }, 

140 }, 

141 } 

142 assert_equal_dict(TIME_PER_REQ_ADAPTIVE, expected, name="TIME_PER_REQ_ADAPTIVE")