Coverage for simulator/constants.py: 100%

1from __future__ import annotations 

2 

3import math 

4 

5from sim_types import WorkflowConfig 

6from sim_types import GPUType 

7from sim_types import Model 

8 

9 

10SECONDS_IN_MINUTE = 60.0 

11SECONDS_IN_HOUR = 60.0 * 60.0 

12 

13# Video resolution constants (16:10) 

14NUM_PIXELS_ORIGINAL = 1280 * 800 

15NUM_PIXELS_ORIGINAL_FLUX = 1280 * 800 

16NUM_PIXELS_ORIGINAL_HF = 512 * 320 

17NUM_PIXELS_ORIGINAL_FT = 640 * 400 

18NUM_PIXELS_ORIGINAL_UPSCALER = 1280 * 800 

19 

20NUM_PIXELS_MEDIUM = 640 * 400 

21NUM_PIXELS_MEDIUM_FLUX = 640 * 400 

22NUM_PIXELS_MEDIUM_HF = 256 * 160 

23NUM_PIXELS_MEDIUM_FT = 320 * 200 

24NUM_PIXELS_MEDIUM_UPSCALER = 640 * 400 

25 

26NUM_PIXELS_LOW = 320 * 200 

27NUM_PIXELS_LOW_FLUX = 320 * 200 

28NUM_PIXELS_LOW_HF = 128 * 80 

29NUM_PIXELS_LOW_FT = 160 * 100 

30NUM_PIXELS_LOW_UPSCALER = 320 * 200 

31 

32# StreamCast constants 

33TOTAL_INPUT_TOKENS = 20 * 1024 # 20K tokens for instructions, PDFs, etc. 

34TOTAL_VIDEO_SECONDS = 10 * 60 # 10 minutes video 

35TOTAL_SUBSCENES = 172 # each subscene is 3.5 seconds -> limited by fantasytalking 81 frames at 23 FPS 

36TOTAL_SCENES = 43 # each scene is 4 subscenes 

37FPS: dict[Model, float] = { 

38 Model.HF: 30, 

39 Model.FT: 23, 

40} 

41NUM_STEPS: dict[Model, int] = { 

42 Model.FLUX: 25, 

43 Model.HF: 10, 

44 Model.FT: 10, 

45} 

46FRAMES_OPTIONS: dict[Model, list[int]] = { 

47 Model.HF: [36, 72, 108, 144, 324], 

48 Model.FT: [9, 21, 41, 61, 77], 

49} 

50FRAMES_PER_STEP_IDX = 4 

51 

52DEFAULT_WORKFLOW_CONFIG = WorkflowConfig( 

53 total_video_seconds=TOTAL_VIDEO_SECONDS, 

54 total_scenes=TOTAL_SCENES, 

55 total_frames={ 

56 Model.HF: math.ceil(TOTAL_VIDEO_SECONDS * FPS[Model.HF]), 

57 Model.FT: math.ceil(TOTAL_VIDEO_SECONDS * FPS[Model.FT]), 

58 }, 

59 total_subscenes=TOTAL_SUBSCENES, 

60 per_subscene_frames={ 

61 Model.HF: math.ceil(TOTAL_VIDEO_SECONDS * FPS[Model.HF] / TOTAL_SUBSCENES), 

62 Model.FT: math.ceil(TOTAL_VIDEO_SECONDS * FPS[Model.FT] / TOTAL_SUBSCENES), 

63 }, 

64 # default per-frame number of denoising steps 

65 num_steps=dict(NUM_STEPS), 

66 # supported number of generation frames 

67 hf_frames=FRAMES_OPTIONS[Model.HF], 

68 ft_frames=FRAMES_OPTIONS[Model.FT], 

69 frames_per_step_idx=FRAMES_PER_STEP_IDX, 

70 total_input_tokens=TOTAL_INPUT_TOKENS, 

71) 

72 

73# Available device counts for scaling 

74# Tensor parallelism (TP) or sequence parallelism (SP) 

75DEVICE_OPTIONS = { 

76 Model.GEMMA: [1, 2, 4, 8], 

77 Model.FLUX: [1, 2, 4, 8, 16], 

78 Model.OTHERS: [1], # Single GPU, no parallelism 

79 Model.HF: [1, 2, 4, 8, 10, 16, 20, 24, 32, 40], 

80 Model.HF_VAE: [1], # Single GPU, no parallelism 

81 Model.FT: [1, 2, 4, 8, 10, 16, 20, 24, 32, 40], 

82 Model.FT_VAE: [1], # Single GPU, no parallelism 

83 Model.UPSCALER: [1, 2, 4, 8], # Single GPU, no parallelism 

84} 

85 

86# Models that only have one instance in the system, so not scaling them across GPU types 

87SINGLE_INSTANCE_MODELS = [ 

88 Model.GEMMA, 

89 Model.FLUX, 

90 Model.OTHERS, 

91] 

92 

93# Models that can only be run on a single GPU 

94SINGLE_DEVICE_MODELS = [ 

95 Model.OTHERS, 

96 Model.HF_VAE, 

97 Model.FT_VAE, 

98] 

99 

100 

101NUM_GPUS_PER_SERVER = { 

102 GPUType.A100: 8, 

103 GPUType.H100: 8, 

104 GPUType.H200: 8, 

105 GPUType.GB200: 8, # This is technically 4 GPUs per server, but nothing fits 

106} 

107 

108 

109POWER_GPU_IDLE = { 

110 GPUType.A100: 65.0, # Watts 

111 GPUType.H100: 80.0, # Watts TODO placeholder value 

112 GPUType.H200: 80.0, # Watts TODO placeholder value 

113 GPUType.GB200: 170.0, # Watts 

114} 

115 

116 

117POWER_GPU_TDP = { 

118 GPUType.A100: 400.0, # Watts 

119 GPUType.H100: 700.0, # Watts 

120 GPUType.H200: 700.0, # Watts 

121 GPUType.GB200: 1200.0, # Watts 

122} 

123 

124 

125# Cost per GPU 

126GPU_SPOT_COST = { 

127 # $ / hour (Spot prices) 

128 GPUType.A100: 1.07, # $8.56 for 8 GPUs 

129 GPUType.H100: 4.03, # $32.24 for 8 GPUs 

130 GPUType.H200: 4.22, # $33.76 for 8 GPUs 

131 GPUType.GB200: 10.76 # $43.04 for 4 GPUs 

132} 

133 

134GPU_RESERVED_COST = { 

135 # $ / hour (Reserved prices) 

136 GPUType.A100: 3.4, # $27.2 for 8 GPUs 

137 GPUType.H100: 5.39, # $43.12 for 8 GPUs 

138 GPUType.H200: 5.64, # $45.12 for 8 GPUs 

139 GPUType.GB200: 14.42 # $57.68 for 4 GPUs 

140} 

141 

142GPU_COST = GPU_SPOT_COST