colossalai
123 строки · 4.0 Кб
1import pytest
2import torch
3import torch.distributed as dist
4from torch.distributed.distributed_c10d import _get_default_group
5
6import colossalai
7from colossalai.accelerator import get_accelerator
8from colossalai.tensor import ColoParameter
9from colossalai.testing import parameterize, rerun_if_address_is_in_use, spawn
10from colossalai.zero.gemini import TensorState
11from colossalai.zero.gemini.chunk import Chunk
12
13
14def dist_sum(x):
15temp = torch.tensor([x], device=get_accelerator().get_current_device())
16dist.all_reduce(temp)
17return temp.item()
18
19
20def add_param(param_list, param_cp_list, *args, **kwargs):
21param = ColoParameter(torch.randn(*args, **kwargs))
22param_list.append(param)
23param_cp_list.append(param.clone())
24
25
26def check_equal(param, param_cp):
27if param.device != param_cp.device:
28temp = param.data.to(param_cp.device)
29else:
30temp = param.data
31return torch.equal(temp, param_cp.data)
32
33
34@parameterize("init_device", [None, torch.device("cpu")])
35@parameterize("keep_gathered", [True, False])
36@parameterize("pin_memory", [True, False])
37def exam_chunk_basic(init_device, keep_gathered, pin_memory):
38world_size = torch.distributed.get_world_size()
39pg = _get_default_group()
40my_chunk = Chunk(
41chunk_size=1024,
42zero_group=pg,
43dtype=torch.float32,
44init_device=init_device,
45cpu_shard_init=True,
46keep_gathered=keep_gathered,
47pin_memory=pin_memory,
48)
49
50param_list = []
51param_cp_list = []
52
53add_param(param_list, param_cp_list, 8, 8, 8, device="cuda")
54add_param(param_list, param_cp_list, 4, 4)
55add_param(param_list, param_cp_list, 4, 8, 2, device="cuda")
56add_param(param_list, param_cp_list, 1, 1, 5)
57
58for param in param_list:
59my_chunk.append_tensor(param)
60assert my_chunk.utilized_size == 597
61for param, param_cp in zip(param_list, param_cp_list):
62check_equal(param, param_cp)
63my_chunk.close_chunk()
64
65if keep_gathered is False:
66assert my_chunk.cpu_shard.size(0) == 1024 // world_size
67assert my_chunk.device_type == "cpu"
68assert my_chunk.can_move
69my_chunk.shard_move(get_accelerator().get_current_device())
70else:
71assert my_chunk.cuda_global_chunk.size(0) == 1024
72assert my_chunk.device_type == "cuda"
73assert not my_chunk.can_move
74
75assert dist_sum(my_chunk.valid_end) == my_chunk.utilized_size
76flag = my_chunk.has_inf_or_nan
77assert not flag, "has_inf_or_nan is {}".format(flag)
78
79my_chunk.access_chunk()
80assert my_chunk.device_type == "cuda"
81for param, param_cp in zip(param_list, param_cp_list):
82check_equal(param, param_cp)
83
84assert my_chunk.tensor_state_cnter[TensorState.HOLD] == 4
85my_chunk.tensor_trans_state(param_list[0], TensorState.COMPUTE)
86assert my_chunk.tensor_state_cnter[TensorState.HOLD] == 3
87assert my_chunk.tensor_state_cnter[TensorState.COMPUTE] == 1
88assert not my_chunk.can_release
89
90for param in param_list:
91my_chunk.tensor_trans_state(param, TensorState.COMPUTE)
92my_chunk.tensor_trans_state(param, TensorState.HOLD_AFTER_BWD)
93my_chunk.tensor_trans_state(param, TensorState.READY_FOR_REDUCE)
94
95assert my_chunk.tensor_state_cnter[TensorState.READY_FOR_REDUCE] == 4
96assert my_chunk.can_reduce
97my_chunk.reduce()
98assert my_chunk.tensor_state_cnter[TensorState.HOLD] == 4
99
100if keep_gathered is False:
101assert my_chunk.cuda_shard.size(0) == 1024 // world_size
102assert my_chunk.device_type == "cuda"
103assert my_chunk.can_move
104else:
105assert my_chunk.cuda_global_chunk.size(0) == 1024
106assert my_chunk.device_type == "cuda"
107assert not my_chunk.can_move
108
109
110def run_dist(rank, world_size, port):
111colossalai.launch(config={}, rank=rank, world_size=world_size, host="localhost", port=port, backend="nccl")
112exam_chunk_basic()
113
114
115@pytest.mark.dist
116@pytest.mark.parametrize("world_size", [1, 2, 4])
117@rerun_if_address_is_in_use()
118def test_chunk_function(world_size):
119spawn(run_dist, world_size)
120
121
122if __name__ == "__main__":
123test_chunk_function(4)
124