library
stringclasses 1
value | test_file
stringclasses 785
values | test_function
stringlengths 1
295
| before
stringlengths 0
448k
| after
stringlengths 0
487k
| context_before
stringclasses 947
values | context_after
stringlengths 0
16.3k
| commit_before
stringclasses 1
value | commit_after
stringclasses 1
value | change_type
stringclasses 3
values |
|---|---|---|---|---|---|---|---|---|---|
torch
|
test/distributed/checkpoint/fsdp/test_fsdp_dsd.py
|
test_1d_fsdp_get_model_state_dict
|
def test_1d_fsdp_get_model_state_dict(self):
self.run_subtests(
{"mlp_dim": [2, 3, 4, 5]},
self._test_1d_fsdp_get_model_state_dict,
)
|
import contextlib
import copy
import torch
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed._composable.fsdp import fully_shard
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed._tensor.experimental import implicit_replication
from torch.distributed.checkpoint.state_dict import (
get_model_state_dict,
get_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType
from torch.distributed.fsdp.wrap import always_wrap_policy
from torch.distributed.tensor.parallel import (
ColwiseParallel,
parallelize_module,
RowwiseParallel,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_fsdp import FSDPTest, MLP
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
from torch.utils._pytree import tree_all_only
class TestFullyShardWithDistributedStateDict(FSDPTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/fsdp/test_fsdp_dsd.py
|
is_cpu
|
def is_cpu(v):
if isinstance(v, DTensor):
return v.device == torch.device("cpu")
else:
return v.device == cpu_device
if self.rank == 0:
self.assertEqual(osd, dsd)
self.assertTrue(tree_all_only((torch.Tensor, DTensor), is_cpu, osd))
else:
self.assertEqual(dsd, {})
|
import contextlib
import copy
import torch
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed._composable.fsdp import fully_shard
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed._tensor.experimental import implicit_replication
from torch.distributed.checkpoint.state_dict import (
get_model_state_dict,
get_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP, StateDictType
from torch.distributed.fsdp.wrap import always_wrap_policy
from torch.distributed.tensor.parallel import (
ColwiseParallel,
parallelize_module,
RowwiseParallel,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_fsdp import FSDPTest, MLP
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
from torch.utils._pytree import tree_all_only
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_dtensor_resharding.py
|
test_dtensor_checkpoint_resharding_with_empty_shard
|
def test_dtensor_checkpoint_resharding_with_empty_shard(self):
"""
Test dtensor checkpoint resharding with dtensor containing empty shards.
"""
tensor = torch.rand(1).cuda()
mesh = init_device_mesh(self.device_type, (self.world_size,))
dtensor = distribute_tensor(tensor, mesh, [Shard(0)])
ref_state_dict = {"dtensor": dtensor}
dist_cp.save_state_dict(
state_dict=ref_state_dict,
storage_writer=dist_cp.FileSystemWriter(path=self.temp_dir),
)
tensor = torch.rand(1).cuda()
mesh_2 = init_device_mesh(self.device_type, (2, self.world_size // 2))
dtensor = distribute_tensor(tensor, mesh_2, [Shard(0), Shard(0)])
state_dict = {"dtensor": dtensor}
dist_cp.load_state_dict(
state_dict=state_dict,
storage_reader=dist_cp.FileSystemReader(self.temp_dir),
)
# TODO: Add a assertEqual for ref_state_dict["dtensor"].full_tensor()
# and state_dict["dtensor"].full_tensor() after we fix the size mismatch
# issue for un-even sharding dtensor.
# TODO: Add dtensor resharding test when world size changes.
|
import torch
import torch.distributed.checkpoint as dist_cp
from torch.distributed._tensor import (
distribute_tensor,
init_device_mesh,
Replicate,
Shard,
zeros,
)
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
skip_if_lt_x_gpu,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
CHECKPOINT_DIR = "checkpoint"
ONE_D_PLACEMENTS = [
[Shard(0)],
[Replicate()],
]
ONE_D_TO_ONE_D_PLACEMENTS = [
([Replicate()], [Shard(0)]),
([Shard(0)], [Replicate()]),
]
TWO_D_PLACEMENTS = [
[Replicate(), Replicate()],
[Replicate(), Shard(0)],
[Shard(0), Replicate()],
[Shard(0), Shard(0)],
]
TWO_D_TO_TWO_D_PLACEMENTS = []
class TestDTensorReshardMeshChange(DTensorTestBase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_format_utils.py
|
forward
|
def forward(self, x):
x = F.relu(self.net1(x))
x = F.relu(self.net2(x))
x = F.relu(self.net3(x))
x = self.net4(x)
return x
|
import torch
import torch.distributed as dist
import torch.distributed.checkpoint as dcp
import torch.nn as nn
import torch.nn.functional as F
from torch.distributed._tensor.device_mesh import init_device_mesh
from torch.distributed.checkpoint.format_utils import (
BroadcastingTorchSaveReader,
dcp_to_torch_save,
DynamicMetaLoadPlanner,
torch_save_to_dcp,
)
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class SimpleModelUneven(nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_format_utils.py
|
get_input
|
def get_input(self):
return torch.rand(4, 5, device="cuda")
|
import torch
import torch.distributed as dist
import torch.distributed.checkpoint as dcp
import torch.nn as nn
import torch.nn.functional as F
from torch.distributed._tensor.device_mesh import init_device_mesh
from torch.distributed.checkpoint.format_utils import (
BroadcastingTorchSaveReader,
dcp_to_torch_save,
DynamicMetaLoadPlanner,
torch_save_to_dcp,
)
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class SimpleModelUneven(nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_fsdp_optim_state.py
|
forward
|
def forward(self, x):
return self.net3(self.net2(self.net1(x)))
|
import torch
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed._shard.sharded_tensor.api import ShardedTensor
from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import (
instantiate_parametrized_tests,
parametrize,
run_tests,
)
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class TestDummyModel(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_fsdp_optim_state.py
|
get_input
|
def get_input(self):
return torch.rand(8, 8, device="cuda")
|
import torch
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed._shard.sharded_tensor.api import ShardedTensor
from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import (
instantiate_parametrized_tests,
parametrize,
run_tests,
)
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class TestDummyModel(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_fsdp_tp_checkpoint_conversion.py
|
test_fsdp_to_tp
|
def test_fsdp_to_tp(self):
CHECKPOINT_DIR = self.temp_dir
model = MLPModule(self.device_type).cuda(self.rank)
# create a FSDP wrapped model
fsdp_model = FSDP(model, use_orig_params=True)
FSDP.set_state_dict_type(
fsdp_model,
StateDictType.SHARDED_STATE_DICT,
)
fsdp_state_dict = fsdp_model.state_dict()
# save fsdp_state_dict to storage
dist_cp.save(
state_dict=fsdp_state_dict,
storage_writer=dist_cp.FileSystemWriter(CHECKPOINT_DIR),
)
# create a TP wrapped model
mesh_shape = (self.world_size,)
device_mesh = init_device_mesh(self.device_type, mesh_shape)
model = MLPModule(self.device_type).cuda(self.rank)
# Parallelize the module based on the given Parallel Style.
parallelize_plan = {
"net1": ColwiseParallel(),
"net2": RowwiseParallel(),
}
tp_model = parallelize_module(model, device_mesh, parallelize_plan)
optimizer = torch.optim.SGD(tp_model.parameters(), lr=0.25)
# Update the parameters so tp_model.state_dict() will be different from fsdp_model.state_dict().
torch.manual_seed(0)
inp = torch.rand(20, 10).cuda(self.rank)
output = tp_model(inp)
output.sum().backward()
optimizer.step()
tp_state_dict = tp_model.state_dict()
# Check parameters are indeed different prior to loading.
for fsdp_item, tp_item in zip(fsdp_state_dict.items(), tp_state_dict.items()):
fsdp_k, fsdp_v = fsdp_item
tp_k, tp_v = tp_item
self.assertEqual(fsdp_k, tp_k)
if isinstance(fsdp_v, ShardedTensor) and isinstance(tp_v, DTensor):
fsdp_redistributed = _all_gather_sharded_tensor(fsdp_v)
tp_redistributed = tp_v.redistribute(
device_mesh, placements=[Replicate()]
).to_local()
self.assertNotEqual(fsdp_redistributed, tp_redistributed)
dist_cp.load_state_dict(
state_dict=tp_state_dict,
storage_reader=dist_cp.FileSystemReader(CHECKPOINT_DIR),
)
tp_model.load_state_dict(tp_state_dict)
# Check parameters are equal after loading.
tp_state_dict_after_load = tp_model.state_dict()
for fsdp_item, tp_item in zip(fsdp_state_dict.items(), tp_state_dict.items()):
fsdp_k, fsdp_v = fsdp_item
tp_k, tp_v = tp_item
self.assertEqual(fsdp_k, tp_k)
if isinstance(fsdp_v, ShardedTensor) and isinstance(tp_v, DTensor):
fsdp_redistributed = _all_gather_sharded_tensor(fsdp_v)
tp_redistributed = tp_v.redistribute(
device_mesh, placements=[Replicate()]
).to_local()
self.assertEqual(fsdp_redistributed, tp_redistributed)
|
import torch
import torch.distributed.checkpoint as dist_cp
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._state_dict_utils import _all_gather_sharded_tensor
from torch.distributed._tensor import DTensor, init_device_mesh, Replicate
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType
from torch.distributed.tensor.parallel import (
ColwiseParallel,
parallelize_module,
RowwiseParallel,
)
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MLPModule,
skip_if_lt_x_gpu,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class TestFsdpTpCheckpointConversion(DTensorTestBase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_fsspec.py
|
forward
|
def forward(self, x):
return self.net4(self.net3(self.net2(self.net1(x))))
|
import shutil
import tempfile
from functools import wraps
from typing import Any, Callable, Dict, Optional, Tuple
import torch
import torch.distributed as dist
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed.checkpoint._fsspec_filesystem import FsspecReader, FsspecWriter
from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict
from torch.distributed.checkpoint.utils import CheckpointException
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType
from torch.testing._internal.common_distributed import requires_nccl, skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._shard.sharded_tensor import (
ShardedTensorTestBase,
with_comms,
)
class MyTestModule(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_fsspec.py
|
opt_at
|
def opt_at(opt, idx):
return list(iter(opt.state.values()))[idx]
# Adam lazily creates its state
self.assertEqual(opt_at(optim, 0)["exp_avg"], opt_at(optim_2, 0)["exp_avg"])
self.assertEqual(
opt_at(optim, 0)["exp_avg_sq"], opt_at(optim_2, 0)["exp_avg_sq"]
)
|
import shutil
import tempfile
from functools import wraps
from typing import Any, Callable, Dict, Optional, Tuple
import torch
import torch.distributed as dist
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed.checkpoint._fsspec_filesystem import FsspecReader, FsspecWriter
from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict
from torch.distributed.checkpoint.utils import CheckpointException
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType
from torch.testing._internal.common_distributed import requires_nccl, skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._shard.sharded_tensor import (
ShardedTensorTestBase,
with_comms,
)
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_fsspec.py
|
test_overwrite
|
def test_overwrite(self):
t1, t2 = torch.randn(10), torch.randn(10)
dcp.save(
{"random": t1}, storage_writer=FsspecWriter(self.temp_dir, overwrite=False)
)
dcp.save(
{"random": t2}, storage_writer=FsspecWriter(self.temp_dir, overwrite=True)
)
sd = {"random": torch.zeros(10)}
dcp.load(sd, checkpoint_id=self.temp_dir)
self.assertTrue(torch.allclose(sd["random"], t2))
with self.assertRaisesRegex(
CheckpointException, ".*Checkpoint already exists.*"
):
dcp.save(
{"random": t2},
storage_writer=FsspecWriter(self.temp_dir, overwrite=False),
)
|
import shutil
import tempfile
from functools import wraps
from typing import Any, Callable, Dict, Optional, Tuple
import torch
import torch.distributed as dist
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed.checkpoint._fsspec_filesystem import FsspecReader, FsspecWriter
from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict
from torch.distributed.checkpoint.utils import CheckpointException
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType
from torch.testing._internal.common_distributed import requires_nccl, skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._shard.sharded_tensor import (
ShardedTensorTestBase,
with_comms,
)
class TestFSSpec(ShardedTensorTestBase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_hsdp_checkpoint.py
|
forward
|
def forward(self, x):
x = F.relu(self.net1(x))
x = F.relu(self.net2(x))
x = F.relu(self.net3(x))
return x
|
from copy import deepcopy
import torch
import torch.distributed.checkpoint as dist_cp
import torch.nn as nn
import torch.nn.functional as F
from torch.distributed._tensor import init_device_mesh, Replicate
from torch.distributed.checkpoint.default_planner import (
DefaultLoadPlanner,
DefaultSavePlanner,
)
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.distributed.fsdp.fully_sharded_data_parallel import (
ShardingStrategy,
StateDictType,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import (
instantiate_parametrized_tests,
parametrize,
run_tests,
)
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class SimpleModel(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_planner.py
|
test_create_read_item_from_chunks
|
def test_create_read_item_from_chunks(self):
tensor_md = TensorStorageMetadata(
properties=TensorProperties.create_from_tensor(torch.empty([16])),
size=torch.Size([16]),
chunks=[
ChunkStorageMetadata(offsets=torch.Size([0]), sizes=torch.Size([8])),
ChunkStorageMetadata(offsets=torch.Size([8]), sizes=torch.Size([8])),
],
)
chunk = ChunkStorageMetadata(offsets=torch.Size([4]), sizes=torch.Size([7]))
read_items = create_read_items_for_chunk_list("foo", tensor_md, [chunk])
self.assertEqual(2, len(read_items))
self.assertEqual(MetadataIndex("foo", [4]), read_items[0].dest_index)
self.assertEqual(torch.Size([0]), read_items[0].dest_offsets)
self.assertEqual(MetadataIndex("foo", [0]), read_items[0].storage_index)
self.assertEqual(torch.Size([4]), read_items[0].storage_offsets)
self.assertEqual(torch.Size([4]), read_items[0].lengths)
self.assertEqual(MetadataIndex("foo", [4]), read_items[1].dest_index)
self.assertEqual(torch.Size([4]), read_items[1].dest_offsets)
self.assertEqual(MetadataIndex("foo", [8]), read_items[1].storage_index)
self.assertEqual(torch.Size([0]), read_items[1].storage_offsets)
self.assertEqual(torch.Size([3]), read_items[1].lengths)
|
import sys
import torch
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed._shard.sharded_tensor import (
Shard,
ShardedTensor,
ShardedTensorMetadata,
ShardMetadata,
)
from torch.distributed._shard.sharded_tensor.metadata import (
TensorProperties as TensorProperties_Shard,
)
from torch.distributed.checkpoint._dedup_save_plans import dedup_save_plans
from torch.distributed.checkpoint.api import CheckpointException
from torch.distributed.checkpoint.default_planner import (
_create_default_local_metadata,
create_default_global_save_plan,
create_default_local_load_plan,
create_default_local_save_plan,
DefaultLoadPlanner,
)
from torch.distributed.checkpoint.metadata import (
BytesStorageMetadata,
ChunkStorageMetadata,
MetadataIndex,
TensorProperties,
TensorStorageMetadata,
)
from torch.distributed.checkpoint.planner import LoadItemType, WriteItemType
from torch.distributed.checkpoint.planner_helpers import (
create_read_items_for_chunk_list,
)
from torch.testing._internal.common_utils import (
run_tests,
TEST_WITH_DEV_DBG_ASAN,
TestCase,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
from torch.testing._internal.distributed.distributed_utils import (
with_dist,
with_fake_comms,
)
class TestPlannerHelpers(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_planner.py
|
test_strict
|
if __name__ == "__main__":
run_tests()
|
def test_strict(self):
original_module = nn.Linear(2, 2)
dcp.save(state_dict={"module": original_module}, checkpoint_id=self.temp_dir)
new_module = nn.Linear(2, 2)
new_module.extra_param = nn.Parameter(torch.randn(2, 2))
dcp.load(
state_dict={"module": new_module},
checkpoint_id=self.temp_dir,
planner=DefaultLoadPlanner(allow_partial_load=True),
)
with self.assertRaisesRegex(CheckpointException, "Missing key in checkpoint"):
dcp.load(
state_dict={"module": new_module},
checkpoint_id=self.temp_dir,
planner=DefaultLoadPlanner(allow_partial_load=False),
)
|
import sys
import torch
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed._shard.sharded_tensor import (
Shard,
ShardedTensor,
ShardedTensorMetadata,
ShardMetadata,
)
from torch.distributed._shard.sharded_tensor.metadata import (
TensorProperties as TensorProperties_Shard,
)
from torch.distributed.checkpoint._dedup_save_plans import dedup_save_plans
from torch.distributed.checkpoint.api import CheckpointException
from torch.distributed.checkpoint.default_planner import (
_create_default_local_metadata,
create_default_global_save_plan,
create_default_local_load_plan,
create_default_local_save_plan,
DefaultLoadPlanner,
)
from torch.distributed.checkpoint.metadata import (
BytesStorageMetadata,
ChunkStorageMetadata,
MetadataIndex,
TensorProperties,
TensorStorageMetadata,
)
from torch.distributed.checkpoint.planner import LoadItemType, WriteItemType
from torch.distributed.checkpoint.planner_helpers import (
create_read_items_for_chunk_list,
)
from torch.testing._internal.common_utils import (
run_tests,
TEST_WITH_DEV_DBG_ASAN,
TestCase,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
from torch.testing._internal.distributed.distributed_utils import (
with_dist,
with_fake_comms,
)
class TestLoadPlanner(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
|
torch
|
test/distributed/checkpoint/test_save_load_api.py
|
forward
|
def forward(self, x):
return self.net4(self.net3(self.net2(self.net1(x))))
|
import os
from unittest.mock import patch
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed._tensor.device_mesh import init_device_mesh
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
skip_if_lt_x_gpu,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class MyTestModule(nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_save_load_api.py
|
test_auto_detect
|
def test_auto_detect(self):
model = FSDP(MyTestModule().cuda())
device_mesh = init_device_mesh(self.device_type, (self.world_size,))
model = FSDP(model, device_mesh=device_mesh)
dcp.save(model.state_dict(), checkpoint_id=os.path.join(self.temp_dir, "first"))
sd = dcp.load(
model.state_dict(), checkpoint_id=os.path.join(self.temp_dir, "first")
)
with patch.object(
dcp.FileSystemReader, "validate_checkpoint_id", return_value=False
) as m1:
with patch.object(
dcp.FileSystemWriter, "validate_checkpoint_id", return_value=False
) as m2:
dcp.save(
model.state_dict(),
checkpoint_id=os.path.join(self.temp_dir, "second"),
)
sd = dcp.load(
model.state_dict(),
checkpoint_id=os.path.join(self.temp_dir, "second"),
)
with self.assertRaisesRegex(RuntimeError, "Cannot detect"):
dcp.save(model.state_dict(), checkpoint_id="abc://abc.abc")
with self.assertRaisesRegex(RuntimeError, "Cannot detect"):
sd = dcp.load(model.state_dict(), checkpoint_id="abc://abc.abc")
|
import os
from unittest.mock import patch
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed._tensor.device_mesh import init_device_mesh
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
skip_if_lt_x_gpu,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class TestSaveAndLoadAPI(DTensorTestBase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict.py
|
init_model_optim
|
def init_model_optim():
if use_dtensor:
device_mesh = init_device_mesh("cuda", (self.world_size,))
orig_model = CompositeParamModel(device=torch.device("cuda"))
orig_optim = optimizer_class(orig_model.parameters(), lr=1e-4, foreach=True)
copy_optim = optimizer_class(orig_model.parameters(), lr=1e-4, foreach=True)
if wrapping:
strategy = set(wrapping)
else:
strategy = {UnitModule}
if use_composable:
dist_model = fully_shard(
copy.deepcopy(orig_model), policy=ModuleWrapPolicy(strategy)
)
else:
if use_dtensor:
device_mesh = init_device_mesh("cuda", (self.world_size,))
dist_model = FSDP(
copy.deepcopy(orig_model),
auto_wrap_policy=ModuleWrapPolicy(strategy),
use_orig_params=use_orig_params,
device_mesh=device_mesh,
)
else:
dist_model = FSDP(
copy.deepcopy(orig_model),
auto_wrap_policy=ModuleWrapPolicy(strategy),
use_orig_params=use_orig_params,
)
if compile_model:
dist_model = torch.compile(dist_model)
dist_optim = optimizer_class(dist_model.parameters(), lr=1e-4, foreach=True)
return orig_model, orig_optim, copy_optim, dist_model, dist_optim
self._test_save_load(init_model_optim)
|
import copy
import functools
import sys
from itertools import chain
from typing import Callable, Tuple, Type, Union
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.distributed._composable import fully_shard, replicate
from torch.distributed._composable.fsdp import (
fully_shard as FSDP2,
fully_shard as fsdp_fully_shard,
)
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
apply_activation_checkpointing,
)
from torch.distributed.checkpoint import state_dict as ptd_state_dict
from torch.distributed.checkpoint.state_dict import (
_patch_model_state_dict,
_patch_optimizer_state_dict,
get_model_state_dict,
get_optimizer_state_dict,
get_state_dict,
set_model_state_dict,
set_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
ShardingStrategy,
StateDictType,
)
from torch.distributed.fsdp.wrap import ModuleWrapPolicy
from torch.distributed.optim import _apply_optimizer_in_backward
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.optim import Optimizer
from torch.testing._internal.common_dist_composable import (
CompositeParamModel,
UnitModule,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MultiProcessTestCase,
with_comms,
)
from torch.testing._internal.distributed.common_state_dict import VerifyStateDictMixin
from torch.utils._pytree import tree_all, tree_all_only
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict.py
|
init_model_optim
|
def init_model_optim():
if use_dtensor:
device_mesh = init_device_mesh("cuda", (self.world_size,))
orig_model = CompositeParamModel(device=torch.device("cuda"))
orig_optim = optimizer_class(orig_model.parameters(), lr=1e-4, foreach=True)
copy_optim = optimizer_class(orig_model.parameters(), lr=1e-4, foreach=True)
if wrapping:
strategy = set(wrapping)
else:
strategy = {UnitModule}
if use_composable:
dist_model = fully_shard(
copy.deepcopy(orig_model), policy=ModuleWrapPolicy(strategy)
)
else:
if use_dtensor:
device_mesh = init_device_mesh("cuda", (self.world_size,))
dist_model = FSDP(
copy.deepcopy(orig_model),
auto_wrap_policy=ModuleWrapPolicy(strategy),
use_orig_params=use_orig_params,
device_mesh=device_mesh,
)
else:
dist_model = FSDP(
copy.deepcopy(orig_model),
auto_wrap_policy=ModuleWrapPolicy(strategy),
use_orig_params=use_orig_params,
)
if compile_model:
dist_model = torch.compile(dist_model)
dist_optim = optimizer_class(dist_model.parameters(), lr=1e-4, foreach=True)
return orig_model, orig_optim, copy_optim, dist_model, dist_optim
self._test_save_load(init_model_optim)
|
import copy
import functools
import sys
from itertools import chain
from typing import Callable, Tuple, Type, Union
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.distributed._composable import fully_shard, replicate
from torch.distributed._composable.fsdp import (
fully_shard as FSDP2,
fully_shard as fsdp_fully_shard,
)
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
apply_activation_checkpointing,
)
from torch.distributed.checkpoint import state_dict as ptd_state_dict
from torch.distributed.checkpoint.state_dict import (
_patch_model_state_dict,
_patch_optimizer_state_dict,
get_model_state_dict,
get_optimizer_state_dict,
get_state_dict,
set_model_state_dict,
set_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
ShardingStrategy,
StateDictType,
)
from torch.distributed.fsdp.wrap import ModuleWrapPolicy
from torch.distributed.optim import _apply_optimizer_in_backward
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.optim import Optimizer
from torch.testing._internal.common_dist_composable import (
CompositeParamModel,
UnitModule,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MultiProcessTestCase,
with_comms,
)
from torch.testing._internal.distributed.common_state_dict import VerifyStateDictMixin
from torch.utils._pytree import tree_all, tree_all_only
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict.py
|
init_model_optim
|
def init_model_optim():
if use_dtensor:
device_mesh = init_device_mesh("cuda", (self.world_size,))
orig_model = CompositeParamModel(device=torch.device("cuda"))
orig_optim = optimizer_class(orig_model.parameters(), lr=1e-4, foreach=True)
copy_optim = optimizer_class(orig_model.parameters(), lr=1e-4, foreach=True)
if wrapping:
strategy = set(wrapping)
else:
strategy = {UnitModule}
if use_composable:
dist_model = fully_shard(
copy.deepcopy(orig_model), policy=ModuleWrapPolicy(strategy)
)
else:
if use_dtensor:
device_mesh = init_device_mesh("cuda", (self.world_size,))
dist_model = FSDP(
copy.deepcopy(orig_model),
auto_wrap_policy=ModuleWrapPolicy(strategy),
use_orig_params=use_orig_params,
device_mesh=device_mesh,
)
else:
dist_model = FSDP(
copy.deepcopy(orig_model),
auto_wrap_policy=ModuleWrapPolicy(strategy),
use_orig_params=use_orig_params,
)
if compile_model:
dist_model = torch.compile(dist_model)
dist_optim = optimizer_class(dist_model.parameters(), lr=1e-4, foreach=True)
return orig_model, orig_optim, copy_optim, dist_model, dist_optim
self._test_save_load(init_model_optim)
|
import copy
import functools
import sys
from itertools import chain
from typing import Callable, Tuple, Type, Union
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.distributed._composable import fully_shard, replicate
from torch.distributed._composable.fsdp import (
fully_shard as FSDP2,
fully_shard as fsdp_fully_shard,
)
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
apply_activation_checkpointing,
)
from torch.distributed.checkpoint import state_dict as ptd_state_dict
from torch.distributed.checkpoint.state_dict import (
_patch_model_state_dict,
_patch_optimizer_state_dict,
get_model_state_dict,
get_optimizer_state_dict,
get_state_dict,
set_model_state_dict,
set_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
ShardingStrategy,
StateDictType,
)
from torch.distributed.fsdp.wrap import ModuleWrapPolicy
from torch.distributed.optim import _apply_optimizer_in_backward
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.optim import Optimizer
from torch.testing._internal.common_dist_composable import (
CompositeParamModel,
UnitModule,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MultiProcessTestCase,
with_comms,
)
from torch.testing._internal.distributed.common_state_dict import VerifyStateDictMixin
from torch.utils._pytree import tree_all, tree_all_only
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict.py
|
init_model_optim
|
def init_model_optim():
if use_dtensor:
device_mesh = init_device_mesh("cuda", (self.world_size,))
orig_model = CompositeParamModel(device=torch.device("cuda"))
orig_optim = optimizer_class(orig_model.parameters(), lr=1e-4, foreach=True)
copy_optim = optimizer_class(orig_model.parameters(), lr=1e-4, foreach=True)
if wrapping:
strategy = set(wrapping)
else:
strategy = {UnitModule}
if use_composable:
dist_model = fully_shard(
copy.deepcopy(orig_model), policy=ModuleWrapPolicy(strategy)
)
else:
if use_dtensor:
device_mesh = init_device_mesh("cuda", (self.world_size,))
dist_model = FSDP(
copy.deepcopy(orig_model),
auto_wrap_policy=ModuleWrapPolicy(strategy),
use_orig_params=use_orig_params,
device_mesh=device_mesh,
)
else:
dist_model = FSDP(
copy.deepcopy(orig_model),
auto_wrap_policy=ModuleWrapPolicy(strategy),
use_orig_params=use_orig_params,
)
if compile_model:
dist_model = torch.compile(dist_model)
dist_optim = optimizer_class(dist_model.parameters(), lr=1e-4, foreach=True)
return orig_model, orig_optim, copy_optim, dist_model, dist_optim
self._test_save_load(init_model_optim)
|
import copy
import functools
import sys
from itertools import chain
from typing import Callable, Tuple, Type, Union
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.distributed._composable import fully_shard, replicate
from torch.distributed._composable.fsdp import (
fully_shard as FSDP2,
fully_shard as fsdp_fully_shard,
)
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
apply_activation_checkpointing,
)
from torch.distributed.checkpoint import state_dict as ptd_state_dict
from torch.distributed.checkpoint.state_dict import (
_patch_model_state_dict,
_patch_optimizer_state_dict,
get_model_state_dict,
get_optimizer_state_dict,
get_state_dict,
set_model_state_dict,
set_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
ShardingStrategy,
StateDictType,
)
from torch.distributed.fsdp.wrap import ModuleWrapPolicy
from torch.distributed.optim import _apply_optimizer_in_backward
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.optim import Optimizer
from torch.testing._internal.common_dist_composable import (
CompositeParamModel,
UnitModule,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MultiProcessTestCase,
with_comms,
)
from torch.testing._internal.distributed.common_state_dict import VerifyStateDictMixin
from torch.utils._pytree import tree_all, tree_all_only
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict.py
|
init_model_optim
|
def init_model_optim():
if use_dtensor:
device_mesh = init_device_mesh("cuda", (self.world_size,))
orig_model = CompositeParamModel(device=torch.device("cuda"))
orig_optim = optimizer_class(orig_model.parameters(), lr=1e-4, foreach=True)
copy_optim = optimizer_class(orig_model.parameters(), lr=1e-4, foreach=True)
if wrapping:
strategy = set(wrapping)
else:
strategy = {UnitModule}
if use_composable:
dist_model = fully_shard(
copy.deepcopy(orig_model), policy=ModuleWrapPolicy(strategy)
)
else:
if use_dtensor:
device_mesh = init_device_mesh("cuda", (self.world_size,))
dist_model = FSDP(
copy.deepcopy(orig_model),
auto_wrap_policy=ModuleWrapPolicy(strategy),
use_orig_params=use_orig_params,
device_mesh=device_mesh,
)
else:
dist_model = FSDP(
copy.deepcopy(orig_model),
auto_wrap_policy=ModuleWrapPolicy(strategy),
use_orig_params=use_orig_params,
)
if compile_model:
dist_model = torch.compile(dist_model)
dist_optim = optimizer_class(dist_model.parameters(), lr=1e-4, foreach=True)
return orig_model, orig_optim, copy_optim, dist_model, dist_optim
self._test_save_load(init_model_optim)
|
import copy
import functools
import sys
from itertools import chain
from typing import Callable, Tuple, Type, Union
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.distributed._composable import fully_shard, replicate
from torch.distributed._composable.fsdp import (
fully_shard as FSDP2,
fully_shard as fsdp_fully_shard,
)
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
apply_activation_checkpointing,
)
from torch.distributed.checkpoint import state_dict as ptd_state_dict
from torch.distributed.checkpoint.state_dict import (
_patch_model_state_dict,
_patch_optimizer_state_dict,
get_model_state_dict,
get_optimizer_state_dict,
get_state_dict,
set_model_state_dict,
set_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
ShardingStrategy,
StateDictType,
)
from torch.distributed.fsdp.wrap import ModuleWrapPolicy
from torch.distributed.optim import _apply_optimizer_in_backward
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.optim import Optimizer
from torch.testing._internal.common_dist_composable import (
CompositeParamModel,
UnitModule,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MultiProcessTestCase,
with_comms,
)
from torch.testing._internal.distributed.common_state_dict import VerifyStateDictMixin
from torch.utils._pytree import tree_all, tree_all_only
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict.py
|
is_cpu
|
def is_cpu(v):
if isinstance(v, DTensor):
return v.device == cpu_device
elif isinstance(v, ShardedTensor):
shards = v.local_shards()
if not shards:
return True
return shards[0].tensor.device == cpu_device
else:
return v.device == cpu_device
self.assertTrue(
tree_all_only((torch.Tensor, DTensor, ShardedTensor), is_cpu, mst)
)
self.assertTrue(
tree_all_only((torch.Tensor, DTensor, ShardedTensor), is_cpu, ost)
)
mst, ost = get_state_dict(
dist_model, dist_optim, options=StateDictOptions(full_state_dict=True)
)
self.assertTrue(
tree_all(lambda v: not isinstance(v, (DTensor, ShardedTensor)), mst)
)
self.assertTrue(
tree_all(lambda v: not isinstance(v, (DTensor, ShardedTensor)), ost)
)
mst, ost = get_state_dict(
dist_model,
dist_optim,
options=StateDictOptions(full_state_dict=True, cpu_offload=True),
)
if self.rank == 0:
self.assertTrue(
tree_all_only((torch.Tensor, DTensor, ShardedTensor), is_cpu, mst)
)
self.assertTrue(
tree_all_only((torch.Tensor, DTensor, ShardedTensor), is_cpu, ost)
)
else:
self.assertEqual(mst, {})
self.assertEqual(ost, {})
|
import copy
import functools
import sys
from itertools import chain
from typing import Callable, Tuple, Type, Union
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.distributed._composable import fully_shard, replicate
from torch.distributed._composable.fsdp import (
fully_shard as FSDP2,
fully_shard as fsdp_fully_shard,
)
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
apply_activation_checkpointing,
)
from torch.distributed.checkpoint import state_dict as ptd_state_dict
from torch.distributed.checkpoint.state_dict import (
_patch_model_state_dict,
_patch_optimizer_state_dict,
get_model_state_dict,
get_optimizer_state_dict,
get_state_dict,
set_model_state_dict,
set_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
ShardingStrategy,
StateDictType,
)
from torch.distributed.fsdp.wrap import ModuleWrapPolicy
from torch.distributed.optim import _apply_optimizer_in_backward
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.optim import Optimizer
from torch.testing._internal.common_dist_composable import (
CompositeParamModel,
UnitModule,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MultiProcessTestCase,
with_comms,
)
from torch.testing._internal.distributed.common_state_dict import VerifyStateDictMixin
from torch.utils._pytree import tree_all, tree_all_only
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict_utils.py
|
create_dtensor
|
def create_dtensor():
device_mesh = self.build_device_mesh()
shard_spec = [Shard(0)]
torch.random.manual_seed(dist.get_rank())
local_tensor = torch.randn(3, 3, 3)
dist_tensor = DTensor.from_local(local_tensor, device_mesh, shard_spec)
tensor = funcol.all_gather_tensor(
dist_tensor.to_local(), gather_dim=0, group=(device_mesh, 0)
)
return tensor, dist_tensor
ltensor, ldtensor = [], []
for i in range(10):
tensor, dtensor = create_dtensor()
ltensor.append(tensor)
ltensor.append(torch.ones(10, device=torch.device("cuda")))
ldtensor.append(dtensor)
ldtensor.append(torch.ones(10, device=torch.device("cuda")))
tensor, dtensor = create_dtensor()
dist_state_dict = {
"local": dtensor,
"list": ldtensor,
"arange": torch.arange(10, device=torch.device("cuda")),
}
state_dict = {
"local": tensor,
"list": ltensor,
"arange": torch.arange(10, device=torch.device("cuda")),
}
self.assertEqual(state_dict, _gather_state_dict(dist_state_dict))
|
import copy
import io
import torch
import torch.distributed as dist
import torch.distributed._functional_collectives as funcol
from torch.distributed._state_dict_utils import (
_check_state_dict_similarity,
_copy_state_dict,
_create_cpu_state_dict,
_distribute_tensors,
_gather_state_dict,
_offload_state_dict_to_cpu,
)
from torch.distributed._tensor import (
distribute_tensor,
DTensor,
init_device_mesh,
Shard,
)
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
skip_if_lt_x_gpu,
with_comms,
)
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict_utils.py
|
_verify
|
def _verify(cpu_state_dict):
# Verify the correctness of _check_state_dict_similarity()
self.assertTrue(_check_state_dict_similarity(state_dict, cpu_state_dict))
tensor1 = cpu_state_dict["tensor1"]
cpu_state_dict["tensor1"] = torch.arange(11)
self.assertFalse(_check_state_dict_similarity(state_dict, cpu_state_dict))
cpu_state_dict["tensor1"] = tensor1
_copy_state_dict(state_dict, cpu_state_dict)
# Verify if _copy_state_dict works
for v in cpu_state_dict.values():
if isinstance(v, torch.Tensor):
self.assertFalse(v.is_cuda)
self.assertEqual(cpu_state_dict["tensor1"], torch.arange(10))
self.assertEqual(cpu_state_dict["tensor2"], torch.ones(10))
buffer.seek(0)
cpu_state_dict["non_tensor_bytes_io"].seek(0)
self.assertEqual(
cpu_state_dict["non_tensor_bytes_io"].read(), buffer.read()
)
buffer.seek(0)
self.assertEqual(cpu_state_dict["non_tensor_bytes"], buffer.read())
self.assertEqual(cpu_state_dict["lr"], 1.5)
self.assertEqual(cpu_state_dict["step"], 7)
self.assertEqual(cpu_state_dict["nested"], {"list": [1, 2, 3, 4]})
cpu_state_dict = _create_cpu_state_dict(state_dict, pin_memory=True)
_verify(cpu_state_dict)
cpu_state_dict = _create_cpu_state_dict(state_dict, share_memory=True)
_verify(cpu_state_dict)
cpu_state_dict = _create_cpu_state_dict(
state_dict, share_memory=True, pin_memory=True
)
_verify(cpu_state_dict)
|
import copy
import io
import torch
import torch.distributed as dist
import torch.distributed._functional_collectives as funcol
from torch.distributed._state_dict_utils import (
_check_state_dict_similarity,
_copy_state_dict,
_create_cpu_state_dict,
_distribute_tensors,
_gather_state_dict,
_offload_state_dict_to_cpu,
)
from torch.distributed._tensor import (
distribute_tensor,
DTensor,
init_device_mesh,
Shard,
)
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
skip_if_lt_x_gpu,
with_comms,
)
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict_utils.py
|
test_state_dict_util_distribute_tensors
|
def test_state_dict_util_distribute_tensors(self):
even_tensor = torch.randn(self.world_size, 2)
uneven_tensor = torch.randn(1, 2)
mesh = init_device_mesh("cuda", mesh_shape=(self.world_size,))
even_dtensor = distribute_tensor(
torch.randn(self.world_size, 2), mesh, [Shard(0)]
)
uneven_dtensor = distribute_tensor(torch.randn(1, 2), mesh, [Shard(0)])
# the dtensor and tensor are different before _distribute_tensors is called.
local_state_dict = {
"even": [even_dtensor, even_tensor],
"uneven": [uneven_dtensor, uneven_tensor],
}
ref_local_state_dict = copy.deepcopy(local_state_dict)
keys = ["even", "uneven"]
_distribute_tensors(local_state_dict, keys, self.device_type)
for local_v, ref_v in zip(
local_state_dict.values(), ref_local_state_dict.values()
):
self.assertEqual(local_v.size(), ref_v[0].size())
self.assertEqual(local_v.stride(), ref_v[0].stride())
self.assertNotEqual(
local_v_full_tensor := local_v.full_tensor(), ref_v[0].full_tensor()
)
self.assertEqual(local_v_full_tensor, ref_v[1])
|
import copy
import io
import torch
import torch.distributed as dist
import torch.distributed._functional_collectives as funcol
from torch.distributed._state_dict_utils import (
_check_state_dict_similarity,
_copy_state_dict,
_create_cpu_state_dict,
_distribute_tensors,
_gather_state_dict,
_offload_state_dict_to_cpu,
)
from torch.distributed._tensor import (
distribute_tensor,
DTensor,
init_device_mesh,
Shard,
)
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
skip_if_lt_x_gpu,
with_comms,
)
class TestStateDictUtils(DTensorTestBase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_tp_checkpoint.py
|
__init__
|
def __init__(self, device):
super().__init__()
torch.manual_seed(5)
self.net1 = torch.nn.Linear(5, 10, device=device)
self.relu = torch.nn.ReLU()
self.net2 = torch.nn.Linear(10, 15, device=device)
self.net3 = torch.nn.Linear(15, 1, device=device)
|
from copy import deepcopy
import torch
import torch.distributed.checkpoint as dcp
from torch.distributed._tensor import init_device_mesh
from torch.distributed.checkpoint.default_planner import (
DefaultLoadPlanner,
DefaultSavePlanner,
)
from torch.distributed.tensor.parallel import (
ColwiseParallel,
parallelize_module,
RowwiseParallel,
)
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MLPModule,
skip_if_lt_x_gpu,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class UnevenShardedModel(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_tp_checkpoint.py
|
forward
|
def forward(self, x):
return self.net3(self.net2(self.relu(self.net1(x))))
|
from copy import deepcopy
import torch
import torch.distributed.checkpoint as dcp
from torch.distributed._tensor import init_device_mesh
from torch.distributed.checkpoint.default_planner import (
DefaultLoadPlanner,
DefaultSavePlanner,
)
from torch.distributed.tensor.parallel import (
ColwiseParallel,
parallelize_module,
RowwiseParallel,
)
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MLPModule,
skip_if_lt_x_gpu,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class UnevenShardedModel(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_tp_checkpoint.py
|
test_tp_checkpoint_load_on_meta_device
|
def test_tp_checkpoint_load_on_meta_device(self):
CHECKPOINT_DIR = self.temp_dir
mesh_shpe = (self.world_size,)
tp_mesh = init_device_mesh(self.device_type, mesh_shpe)
# create model and move it to GPU with id rank
model = UnevenShardedModel(self.device_type).cuda(self.rank)
# Parallelize the module based on the given Parallel Style.
parallelize_plan = {
"net1": ColwiseParallel(),
"net2": RowwiseParallel(),
"net3": ColwiseParallel(),
}
model = parallelize_module(model, tp_mesh, parallelize_plan=parallelize_plan)
original_state_dict = {
"model": model.state_dict(),
}
dcp.save(
state_dict=original_state_dict,
storage_writer=dcp.FileSystemWriter(CHECKPOINT_DIR),
)
model2 = parallelize_module(
UnevenShardedModel("meta"), tp_mesh, parallelize_plan=parallelize_plan
)
model2_sd_before_load = model2.state_dict()
state_dict_to_load = {"model": model2_sd_before_load}
dcp.load(
state_dict=state_dict_to_load,
storage_reader=dcp.FileSystemReader(CHECKPOINT_DIR),
)
# We need to make sure state_dict_to_load["model"] is the same as state_dict_after_load["model"],
# since we are doing in-place loading.
self.assertTrue(state_dict_to_load["model"] is model2_sd_before_load)
model2.load_state_dict(state_dict_to_load["model"], assign=True)
state_dict_after_load = {"model": model2.state_dict()}
self.assertEqual(
len(original_state_dict["model"]), len(state_dict_to_load["model"])
)
self.assertEqual(
len(original_state_dict["model"]), len(state_dict_after_load["model"])
)
for name, param in original_state_dict["model"].items():
param_to_load = state_dict_to_load["model"][name]
param_after_load = state_dict_after_load["model"][name]
# we need to explicitly check the device is not meta as the assertEqual check
# currently doesn't handle DTensor with meta device.
self.assertTrue(not param_to_load.is_meta)
self.assertTrue(not param_after_load.is_meta)
self.assertEqual(param.to_local(), param_to_load.to_local())
self.assertEqual(param.to_local(), param_after_load.to_local())
|
from copy import deepcopy
import torch
import torch.distributed.checkpoint as dcp
from torch.distributed._tensor import init_device_mesh
from torch.distributed.checkpoint.default_planner import (
DefaultLoadPlanner,
DefaultSavePlanner,
)
from torch.distributed.tensor.parallel import (
ColwiseParallel,
parallelize_module,
RowwiseParallel,
)
from torch.testing._internal.common_utils import run_tests
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MLPModule,
skip_if_lt_x_gpu,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class TestTpCheckpoint(DTensorTestBase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_traverse.py
|
collect_data
|
def collect_data(path, value):
nonlocal data
data[path] = value
_traverse.traverse_state_dict(state_dict, collect_data)
self.assertIn(("key0",), data)
self.assertEqual(data[("key0",)], 1)
self.assertIn(("key1",), data)
self.assertEqual(data[("key1",)], [1, 2])
self.assertIn(("key2",), data)
self.assertEqual(data[("key2",)], {1: 2, 2: 3})
self.assertIn(("key3",), data)
self.assertEqual(data[("key3",)], torch.tensor([1]))
|
def collect_data(path, value):
nonlocal data
data[path] = value
_traverse.traverse_state_dict(state_dict, collect_data)
self.assertIn(("key0",), data)
self.assertEqual(data[("key0",)], 1)
self.assertIn(("key1",), data)
self.assertEqual(data[("key1",)], [1, 2])
self.assertIn(("key2", "1"), data)
self.assertEqual(data[("key2", "1")], 2)
self.assertIn(("key2", "2"), data)
self.assertEqual(data[("key2", "2")], 3)
self.assertIn(("key3",), data)
self.assertEqual(data[("key3",)], torch.tensor([1]))
|
from collections import OrderedDict
import torch
import torch.distributed.checkpoint._traverse as _traverse
from torch.distributed.checkpoint.metadata import STATE_DICT_TYPE
from torch.testing._internal.common_utils import run_tests, TestCase
|
from collections import OrderedDict
from typing import TYPE_CHECKING
import torch
import torch.distributed.checkpoint._traverse as _traverse
from torch.testing._internal.common_utils import run_tests, TestCase
from torch.distributed.checkpoint.metadata import STATE_DICT_TYPE
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/checkpoint/test_checkpoint.py
|
_test_dist_failure
|
def _test_dist_failure(self, callback, kwargs):
bad_ranks = list(kwargs.values())[0] if len(kwargs) > 0 else []
# Empty bad_ranks means it must work
if len(bad_ranks) == 0:
callback()
else:
with self.assertRaises(CheckpointException) as cm:
callback()
e = cast(CheckpointException, cm.exception)
for rank, wrapped_ex in e.failures.items():
ex = wrapped_ex[0]
self.assertTrue(rank in bad_ranks, msg=f"{rank} did not fail")
if not kwargs.get("ignore_exception_type", False):
self.assertEqual(ValueError, type(ex), str(ex))
failed_ranks = e.failures.keys()
for rank in bad_ranks:
self.assertTrue(
rank in failed_ranks,
msg=f"{rank} was supposed to fail was fine",
)
|
def _test_dist_failure(self, callback, kwargs):
bad_ranks = next(iter(kwargs.values())) if len(kwargs) > 0 else []
# Empty bad_ranks means it must work
if len(bad_ranks) == 0:
callback()
else:
with self.assertRaises(CheckpointException) as cm:
callback()
e = cast(CheckpointException, cm.exception)
for rank, wrapped_ex in e.failures.items():
ex = wrapped_ex[0]
self.assertTrue(rank in bad_ranks, msg=f"{rank} did not fail")
if not kwargs.get("ignore_exception_type", False):
self.assertEqual(ValueError, type(ex), str(ex))
failed_ranks = e.failures.keys()
for rank in bad_ranks:
self.assertTrue(
rank in failed_ranks,
msg=f"{rank} was supposed to fail was fine",
)
|
import sys
from typing import Optional, List, cast
from torch.distributed.checkpoint.storage import WriteResult
from torch.distributed.checkpoint import (
StorageReader,
StorageWriter,
CheckpointException,
load_state_dict,
save_state_dict,
)
import torch
import torch.distributed as dist
import torch.nn
import torch.futures
from torch.futures import Future
from torch.distributed._shard import sharded_tensor
from torch.distributed.checkpoint.default_planner import (
_create_default_local_metadata,
)
from torch.distributed.checkpoint.metadata import (
BytesStorageMetadata,
Metadata,
TensorStorageMetadata,
)
from torch.distributed.checkpoint.planner import (
SavePlan,
SavePlanner,
LoadPlan,
LoadPlanner,
)
from torch.distributed._shard.sharded_tensor import (
state_dict_hook,
ShardedTensor,
)
from torch.distributed._shard.sharding_spec import ChunkShardingSpec
from torch.testing._internal.common_distributed import (
requires_nccl,
skip_if_lt_x_gpu,
)
from torch.testing._internal.distributed._shard.sharded_tensor import (
ShardedTensorTestBase,
with_comms,
)
from torch.testing._internal.common_utils import (
TEST_WITH_DEV_DBG_ASAN,
run_tests,
)
class TestDistributedFailure(ShardedTensorTestBase):
|
import os
import sys
from typing import cast, List, Optional, Union
import torch
import torch.distributed as dist
import torch.futures
import torch.nn
from torch.distributed._shard import sharded_tensor
from torch.distributed._shard.sharded_tensor import ShardedTensor, state_dict_hook
from torch.distributed._shard.sharding_spec import ChunkShardingSpec
from torch.distributed.checkpoint import (
CheckpointException,
load_state_dict,
save_state_dict,
StorageReader,
StorageWriter,
)
from torch.distributed.checkpoint.default_planner import _create_default_local_metadata
from torch.distributed.checkpoint.metadata import (
BytesStorageMetadata,
Metadata,
TensorStorageMetadata,
)
from torch.distributed.checkpoint.planner import (
LoadPlan,
LoadPlanner,
SavePlan,
SavePlanner,
)
from torch.distributed.checkpoint.storage import WriteResult
from torch.futures import Future
from torch.testing._internal.common_distributed import requires_nccl, skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._shard.sharded_tensor import (
ShardedTensorTestBase,
with_comms,
)
class TestDistributedFailure(ShardedTensorTestBase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/checkpoint/test_state_dict.py
|
get_extra_state
|
def get_extra_state(self):
return "MyState"
|
import copy
import functools
import sys
from itertools import chain
from typing import Callable, Tuple, Type, Union
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.distributed._composable import fully_shard, replicate
from torch.distributed._composable.fsdp import (
fully_shard as FSDP2,
fully_shard as fsdp_fully_shard,
)
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
apply_activation_checkpointing,
)
from torch.distributed.checkpoint import state_dict as ptd_state_dict
from torch.distributed.checkpoint.state_dict import (
_patch_model_state_dict,
_patch_optimizer_state_dict,
get_model_state_dict,
get_optimizer_state_dict,
get_state_dict,
set_model_state_dict,
set_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
ShardingStrategy,
StateDictType,
)
from torch.distributed.fsdp.wrap import ModuleWrapPolicy
from torch.distributed.optim import _apply_optimizer_in_backward
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.optim import Optimizer
from torch.testing._internal.common_dist_composable import (
CompositeParamModel,
UnitModule,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MultiProcessTestCase,
with_comms,
)
from torch.testing._internal.distributed.common_state_dict import VerifyStateDictMixin
from torch.utils._pytree import tree_all, tree_all_only
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict.py
|
set_extra_state
|
def set_extra_state(self, state):
return
UnitModule.get_extra_state = get_extra_state
UnitModule.set_extra_state = set_extra_state
ddp_model = DDP(copy.deepcopy(model))
set_model_state_dict(ddp_model, get_model_state_dict(ddp_model))
self.assertEqual(model.state_dict()["u1._extra_state"], "MyState")
self.assertEqual(model.state_dict(), get_model_state_dict(ddp_model))
|
import copy
import functools
import sys
from itertools import chain
from typing import Callable, Tuple, Type, Union
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.distributed._composable import fully_shard, replicate
from torch.distributed._composable.fsdp import (
fully_shard as FSDP2,
fully_shard as fsdp_fully_shard,
)
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
apply_activation_checkpointing,
)
from torch.distributed.checkpoint import state_dict as ptd_state_dict
from torch.distributed.checkpoint.state_dict import (
_patch_model_state_dict,
_patch_optimizer_state_dict,
get_model_state_dict,
get_optimizer_state_dict,
get_state_dict,
set_model_state_dict,
set_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
ShardingStrategy,
StateDictType,
)
from torch.distributed.fsdp.wrap import ModuleWrapPolicy
from torch.distributed.optim import _apply_optimizer_in_backward
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.optim import Optimizer
from torch.testing._internal.common_dist_composable import (
CompositeParamModel,
UnitModule,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MultiProcessTestCase,
with_comms,
)
from torch.testing._internal.distributed.common_state_dict import VerifyStateDictMixin
from torch.utils._pytree import tree_all, tree_all_only
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict.py
|
check
|
def check(equal):
fsdp_states = get_model_state_dict(
fsdp_model,
options=StateDictOptions(full_state_dict=True),
)
fsdp_optim_states = get_optimizer_state_dict(
fsdp_model,
fsdp_optim,
options=StateDictOptions(full_state_dict=True),
)
if equal:
self.assertEqual(states, fsdp_states)
self.assertEqual(optim_states, fsdp_optim_states)
else:
self.assertNotEqual(states, fsdp_states)
self.assertNotEqual(optim_states, fsdp_optim_states)
check(equal=True)
fsdp_model(batch).sum().backward()
fsdp_optim.step()
check(equal=False)
# Drop the states to simulate loading from rank0
if dist.get_rank() > 0:
load_states = {}
load_states2 = {}
load_optim_states = {}
else:
load_states = copy.deepcopy(states)
load_states2 = copy.deepcopy(states)
load_optim_states = copy.deepcopy(optim_states)
set_model_state_dict(
fsdp_model,
model_state_dict=load_states,
options=StateDictOptions(broadcast_from_rank0=True, full_state_dict=True),
)
set_optimizer_state_dict(
fsdp_model,
fsdp_optim,
optim_state_dict=load_optim_states,
options=StateDictOptions(broadcast_from_rank0=True, full_state_dict=True),
)
check(equal=True)
# Verify the `strict` flag.
load_states = load_states2
if load_states:
key = next(iter(load_states.keys()))
load_states.pop(key)
with self.assertRaisesRegex(RuntimeError, "Missing key"):
set_model_state_dict(
fsdp_model,
model_state_dict=load_states,
options=StateDictOptions(
broadcast_from_rank0=True, full_state_dict=True
),
)
|
import copy
import functools
import sys
from itertools import chain
from typing import Callable, Tuple, Type, Union
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.distributed._composable import fully_shard, replicate
from torch.distributed._composable.fsdp import (
fully_shard as FSDP2,
fully_shard as fsdp_fully_shard,
)
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
apply_activation_checkpointing,
)
from torch.distributed.checkpoint import state_dict as ptd_state_dict
from torch.distributed.checkpoint.state_dict import (
_patch_model_state_dict,
_patch_optimizer_state_dict,
get_model_state_dict,
get_optimizer_state_dict,
get_state_dict,
set_model_state_dict,
set_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
ShardingStrategy,
StateDictType,
)
from torch.distributed.fsdp.wrap import ModuleWrapPolicy
from torch.distributed.optim import _apply_optimizer_in_backward
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.optim import Optimizer
from torch.testing._internal.common_dist_composable import (
CompositeParamModel,
UnitModule,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MultiProcessTestCase,
with_comms,
)
from torch.testing._internal.distributed.common_state_dict import VerifyStateDictMixin
from torch.utils._pytree import tree_all, tree_all_only
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict.py
|
__init__
|
def __init__(self, vocab_size, embedding_dim):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim)
self.decoder = nn.Linear(embedding_dim, vocab_size)
self.decoder.weight = self.embedding.weight # Tying weights
|
import copy
import functools
import sys
from itertools import chain
from typing import Callable, Tuple, Type, Union
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.distributed._composable import fully_shard, replicate
from torch.distributed._composable.fsdp import (
fully_shard as FSDP2,
fully_shard as fsdp_fully_shard,
)
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
apply_activation_checkpointing,
)
from torch.distributed.checkpoint import state_dict as ptd_state_dict
from torch.distributed.checkpoint.state_dict import (
_patch_model_state_dict,
_patch_optimizer_state_dict,
get_model_state_dict,
get_optimizer_state_dict,
get_state_dict,
set_model_state_dict,
set_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
ShardingStrategy,
StateDictType,
)
from torch.distributed.fsdp.wrap import ModuleWrapPolicy
from torch.distributed.optim import _apply_optimizer_in_backward
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.optim import Optimizer
from torch.testing._internal.common_dist_composable import (
CompositeParamModel,
UnitModule,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MultiProcessTestCase,
with_comms,
)
from torch.testing._internal.distributed.common_state_dict import VerifyStateDictMixin
from torch.utils._pytree import tree_all, tree_all_only
class TiedEmbeddingModel(nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict.py
|
forward
|
def forward(self, input):
input = (input * 10).to(torch.int)
embedded = self.embedding(input)
output = self.decoder(embedded)
return output
|
import copy
import functools
import sys
from itertools import chain
from typing import Callable, Tuple, Type, Union
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.distributed._composable import fully_shard, replicate
from torch.distributed._composable.fsdp import (
fully_shard as FSDP2,
fully_shard as fsdp_fully_shard,
)
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
apply_activation_checkpointing,
)
from torch.distributed.checkpoint import state_dict as ptd_state_dict
from torch.distributed.checkpoint.state_dict import (
_patch_model_state_dict,
_patch_optimizer_state_dict,
get_model_state_dict,
get_optimizer_state_dict,
get_state_dict,
set_model_state_dict,
set_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
ShardingStrategy,
StateDictType,
)
from torch.distributed.fsdp.wrap import ModuleWrapPolicy
from torch.distributed.optim import _apply_optimizer_in_backward
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.optim import Optimizer
from torch.testing._internal.common_dist_composable import (
CompositeParamModel,
UnitModule,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MultiProcessTestCase,
with_comms,
)
from torch.testing._internal.distributed.common_state_dict import VerifyStateDictMixin
from torch.utils._pytree import tree_all, tree_all_only
class TiedEmbeddingModel(nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_state_dict.py
|
init_model_optim
|
def init_model_optim():
if use_dtensor:
device_mesh = init_device_mesh("cuda", (self.world_size,))
orig_model = CompositeParamModel(device=torch.device("cuda"))
orig_optim = optimizer_class(orig_model.parameters(), lr=1e-4, foreach=True)
copy_optim = optimizer_class(orig_model.parameters(), lr=1e-4, foreach=True)
if wrapping:
strategy = set(wrapping)
else:
strategy = {UnitModule}
if use_composable:
dist_model = fully_shard(
copy.deepcopy(orig_model), policy=ModuleWrapPolicy(strategy)
)
else:
if use_dtensor:
device_mesh = init_device_mesh("cuda", (self.world_size,))
dist_model = FSDP(
copy.deepcopy(orig_model),
auto_wrap_policy=ModuleWrapPolicy(strategy),
use_orig_params=use_orig_params,
device_mesh=device_mesh,
)
else:
dist_model = FSDP(
copy.deepcopy(orig_model),
auto_wrap_policy=ModuleWrapPolicy(strategy),
use_orig_params=use_orig_params,
)
if compile_model:
dist_model = torch.compile(dist_model)
dist_optim = optimizer_class(dist_model.parameters(), lr=1e-4, foreach=True)
return orig_model, orig_optim, copy_optim, dist_model, dist_optim
self._test_save_load(init_model_optim)
|
import copy
import functools
import sys
from itertools import chain
from typing import Callable, Tuple, Type, Union
import torch
import torch.distributed as dist
import torch.nn as nn
from torch.distributed._composable import fully_shard, replicate
from torch.distributed._composable.fsdp import (
fully_shard as FSDP2,
fully_shard as fsdp_fully_shard,
)
from torch.distributed._shard.sharded_tensor import ShardedTensor
from torch.distributed._tensor import DTensor, init_device_mesh
from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
apply_activation_checkpointing,
)
from torch.distributed.checkpoint import state_dict as ptd_state_dict
from torch.distributed.checkpoint.state_dict import (
_patch_model_state_dict,
_patch_optimizer_state_dict,
get_model_state_dict,
get_optimizer_state_dict,
get_state_dict,
set_model_state_dict,
set_optimizer_state_dict,
StateDictOptions,
)
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
ShardingStrategy,
StateDictType,
)
from torch.distributed.fsdp.wrap import ModuleWrapPolicy
from torch.distributed.optim import _apply_optimizer_in_backward
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.optim import Optimizer
from torch.testing._internal.common_dist_composable import (
CompositeParamModel,
UnitModule,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import run_tests, TEST_WITH_DEV_DBG_ASAN
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
MultiProcessTestCase,
with_comms,
)
from torch.testing._internal.distributed.common_state_dict import VerifyStateDictMixin
from torch.utils._pytree import tree_all, tree_all_only
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_hsdp_checkpoint.py
|
get_input
|
def get_input(self):
return torch.rand(4, 5, device="cuda")
|
from copy import deepcopy
import torch
import torch.distributed.checkpoint as dist_cp
import torch.nn as nn
import torch.nn.functional as F
from torch.distributed._tensor import init_device_mesh, Replicate
from torch.distributed.checkpoint.default_planner import (
DefaultLoadPlanner,
DefaultSavePlanner,
)
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.distributed.fsdp.fully_sharded_data_parallel import (
ShardingStrategy,
StateDictType,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import (
instantiate_parametrized_tests,
parametrize,
run_tests,
)
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class SimpleModel(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_hsdp_checkpoint.py
|
forward
|
def forward(self, x):
x = F.relu(self.net1(x))
x = F.relu(self.net2(x))
x = F.relu(self.net3(x))
return x
|
from copy import deepcopy
import torch
import torch.distributed.checkpoint as dist_cp
import torch.nn as nn
import torch.nn.functional as F
from torch.distributed._tensor import init_device_mesh, Replicate
from torch.distributed.checkpoint.default_planner import (
DefaultLoadPlanner,
DefaultSavePlanner,
)
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.distributed.fsdp.fully_sharded_data_parallel import (
ShardingStrategy,
StateDictType,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import (
instantiate_parametrized_tests,
parametrize,
run_tests,
)
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class SimpleModel(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_hsdp_checkpoint.py
|
get_input
|
def get_input(self):
return torch.rand(4, 5, device="cuda")
|
from copy import deepcopy
import torch
import torch.distributed.checkpoint as dist_cp
import torch.nn as nn
import torch.nn.functional as F
from torch.distributed._tensor import init_device_mesh, Replicate
from torch.distributed.checkpoint.default_planner import (
DefaultLoadPlanner,
DefaultSavePlanner,
)
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.distributed.fsdp.fully_sharded_data_parallel import (
ShardingStrategy,
StateDictType,
)
from torch.testing._internal.common_distributed import skip_if_lt_x_gpu
from torch.testing._internal.common_utils import (
instantiate_parametrized_tests,
parametrize,
run_tests,
)
from torch.testing._internal.distributed._tensor.common_dtensor import (
DTensorTestBase,
with_comms,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
class SimpleModel(torch.nn.Module):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_planner.py
|
create_sharded_tensor
|
def create_sharded_tensor(rank, world_size, shards_per_rank, shard_size=8):
shards_metadata = []
local_shards = []
for idx in range(0, world_size * shards_per_rank):
shard_rank = idx // shards_per_rank
shard_md = ShardMetadata(shard_offsets=[idx * shard_size], shard_sizes=[shard_size], placement=f"rank:{shard_rank}/cpu")
shards_metadata.append(shard_md)
if shard_rank == rank:
shard = Shard.from_tensor_and_offsets(
torch.rand(*shard_md.shard_sizes),
shard_offsets=shard_md.shard_offsets,
rank=rank
)
local_shards.append(shard)
sharded_tensor_md = ShardedTensorMetadata(
shards_metadata=shards_metadata,
size=torch.Size([shard_size * len(shards_metadata)]),
tensor_properties=TensorProperties.create_from_tensor(torch.zeros(1))
)
return ShardedTensor._init_from_local_shards_and_global_metadata(
local_shards=local_shards,
sharded_tensor_metadata=sharded_tensor_md
)
class TestSavePlan(TestCase):
@with_fake_comms(rank=1, world_size=4)
def test_local_plan(self):
tensor = torch.rand(10)
val = [1, 2, 3]
st = create_sharded_tensor(rank=1, world_size=4, shards_per_rank=1)
state_dict = {
"tensor": tensor,
"value": val,
"st": st
}
plan = create_default_local_save_plan(state_dict, False)
self.assertEqual(1, len(plan.items))
wi = plan.items[0]
self.assertEqual(wi.index, MetadataIndex("st", [8]))
self.assertEqual(wi.type, WriteItemType.SHARD)
self.assertEqual(wi.tensor_data.size, st.size())
self.assertEqual(wi.tensor_data.properties, TensorProperties.create_from_tensor(torch.zeros(1)))
self.assertEqual(wi.tensor_data.chunk.offsets, torch.Size([8]))
self.assertEqual(wi.tensor_data.chunk.sizes, torch.Size([8]))
# Coordinator rank, should include replicated items as well
plan = create_default_local_save_plan(state_dict, True)
self.assertEqual(3, len(plan.items))
tensor_wi = next(wi for wi in plan.items if wi.type == WriteItemType.TENSOR)
self.assertEqual(tensor_wi.index, MetadataIndex("tensor", [0]))
self.assertEqual(tensor_wi.tensor_data.size, tensor.size())
self.assertEqual(tensor_wi.tensor_data.properties, TensorProperties.create_from_tensor(tensor))
self.assertEqual(tensor_wi.tensor_data.chunk.offsets, torch.Size([0]))
self.assertEqual(tensor_wi.tensor_data.chunk.sizes, torch.Size([10]))
bytes_wi = next(wi for wi in plan.items if wi.type == WriteItemType.BYTE_IO)
self.assertEqual(bytes_wi.index, MetadataIndex("value"))
self.assertIsNone(bytes_wi.tensor_data)
def test_global_plan(self):
def create_data(rank):
with with_dist(rank=rank, world_size=4):
tensor = torch.rand(10)
val = [1, 2, 3]
st = create_sharded_tensor(rank=rank, world_size=4, shards_per_rank=1)
state_dict = {
"tensor": tensor,
"value": val,
"st": st
}
return create_default_local_save_plan(state_dict, rank == 0)
all_plans = [create_data(0), create_data(1), create_data(2), create_data(3)]
final_plans, metadata = create_default_global_save_plan(all_plans=all_plans)
# The default global plan updates all indexes to include hints
for new_plan, old_plan in zip(final_plans, all_plans):
for new_item, old_item in zip(new_plan.items, old_plan.items):
self.assertEqual(new_item.index, old_item.index)
self.assertEqual(new_item.type, old_item.type)
self.assertEqual(new_item.tensor_data, old_item.tensor_data)
self.assertIn(new_item.index.fqn, metadata.state_dict_metadata)
item_md = metadata.state_dict_metadata[new_item.index.fqn]
if new_item.type == WriteItemType.BYTE_IO:
self.assertTrue(isinstance(item_md, BytesStorageMetadata))
else:
self.assertTrue(isinstance(item_md, TensorStorageMetadata))
self.assertEqual(item_md.size, old_item.tensor_data.size)
self.assertEqual(item_md.properties, old_item.tensor_data.properties)
self.assertIsNotNone(new_item.index.index)
# Make sure the hint is correct
self.assertEqual(item_md.chunks[new_item.index.index], old_item.tensor_data.chunk)
def test_local_load_plan(self):
def create_state_dict(rank):
with with_dist(rank=rank, world_size=4):
tensor = torch.rand(10)
val = [1, 2, 3]
st = create_sharded_tensor(rank=rank, world_size=4, shards_per_rank=1)
return {
"tensor": tensor,
"value": val,
"st": st
}
state_dict = create_state_dict(1)
metadata = _create_default_local_metadata(state_dict)
load_plan = create_default_local_load_plan(state_dict, metadata)
# This will create 3 entries
self.assertEqual(3, len(load_plan.items))
st_item = next(ri for ri in load_plan.items if ri.dest_index.fqn == "st")
tensor_item = next(ri for ri in load_plan.items if ri.dest_index.fqn == "tensor")
bytes_item = next(ri for ri in load_plan.items if ri.dest_index.fqn == "value")
self.assertEqual(st_item.type, LoadItemType.TENSOR)
# This is an exact copy
self.assertEqual(st_item.dest_index, MetadataIndex("st", [8]))
self.assertEqual(st_item.dest_offsets, torch.Size([0]))
self.assertEqual(st_item.storage_index, MetadataIndex("st", [8]))
self.assertEqual(st_item.storage_offsets, torch.Size([0]))
self.assertEqual(st_item.lengths, torch.Size([8]))
self.assertEqual(tensor_item.type, LoadItemType.TENSOR)
self.assertEqual(tensor_item.dest_index, MetadataIndex("tensor", [0]))
self.assertEqual(tensor_item.dest_offsets, torch.Size([0]))
self.assertEqual(tensor_item.storage_index, MetadataIndex("tensor", [0]))
self.assertEqual(tensor_item.storage_offsets, torch.Size([0]))
self.assertEqual(tensor_item.lengths, torch.Size([10]))
self.assertEqual(bytes_item.type, LoadItemType.BYTE_IO)
self.assertEqual(bytes_item.dest_index, MetadataIndex("value"))
def test_load_with_resharding(self):
def create_state_dict(rank, world_size):
with with_dist(rank=rank, world_size=world_size):
return {
"st": create_sharded_tensor(
rank=rank,
world_size=world_size,
shards_per_rank=1,
shard_size=128 // world_size,
)
}
# Rank 1 has a 16 bytes shard from [16, 32[
world8_state_dict = create_state_dict(rank=1, world_size=8)
world8_metadata = _create_default_local_metadata(world8_state_dict)
# Rank 1 has a 32 bytes shard from [32, 64[
world4_state_dict = create_state_dict(rank=1, world_size=4)
world4_metadata = _create_default_local_metadata(world4_state_dict)
# First scenario, going from world=8 to world=4, need to load 2 shards
# Each 4-world shard has 32 elements, so it needs to load 2 shards
load_plan = create_default_local_load_plan(world4_state_dict, world8_metadata)
self.assertEqual(2, len(load_plan.items))
low_ri = next(ri for ri in load_plan.items if ri.dest_offsets == torch.Size([0]))
high_ri = next(ri for ri in load_plan.items if ri.dest_offsets == torch.Size([16]))
self.assertEqual(low_ri.storage_index, MetadataIndex("st", [32]))
self.assertEqual(low_ri.storage_offsets, torch.Size([0]))
self.assertEqual(low_ri.dest_index, MetadataIndex("st", [32]))
self.assertEqual(low_ri.dest_offsets, torch.Size([0]))
self.assertEqual(low_ri.lengths, torch.Size([16]))
self.assertEqual(high_ri.storage_index, MetadataIndex("st", [48]))
self.assertEqual(high_ri.storage_offsets, torch.Size([0]))
self.assertEqual(high_ri.dest_index, MetadataIndex("st", [32]))
self.assertEqual(high_ri.dest_offsets, torch.Size([16]))
self.assertEqual(high_ri.lengths, torch.Size([16]))
# Second scenario, going from world=4 to world=8, need to load half of 1 shard
# rank1 on 8-world needs to load the upper half of the rank0 4-world shard
load_plan = create_default_local_load_plan(world8_state_dict, world4_metadata)
self.assertEqual(1, len(load_plan.items))
ri = load_plan.items[0]
self.assertEqual(ri.storage_index, MetadataIndex("st", [0]))
self.assertEqual(ri.storage_offsets, torch.Size([16]))
self.assertEqual(ri.dest_index, MetadataIndex("st", [16]))
self.assertEqual(ri.dest_offsets, torch.Size([0]))
self.assertEqual(ri.lengths, torch.Size([16]))
def test_load_with_world_size_diff_by_one(self):
def create_state_dict(rank, world_size):
with with_dist(rank=rank, world_size=world_size):
return {
"st": create_sharded_tensor(
rank=rank,
world_size=world_size,
shards_per_rank=1,
shard_size=120 // world_size,
)
}
# rank 1 has a 30 bytes shard from [30, 60[
world4_state_dict = create_state_dict(rank=1, world_size=4)
world4_metadata = _create_default_local_metadata(world4_state_dict)
# rank 1 has a 40 bytes shard from [40, 80[
world3_state_dict = create_state_dict(rank=1, world_size=3)
load_plan = create_default_local_load_plan(world3_state_dict, world4_metadata)
self.assertEqual(2, len(load_plan.items))
# this is [30, 60] to load [40, 60]
low_ri = next(ri for ri in load_plan.items if ri.dest_offsets == torch.Size([0]))
# this is [60, 90] to load [60, 80]
high_ri = next(ri for ri in load_plan.items if ri.dest_offsets == torch.Size([20]))
self.assertEqual(low_ri.storage_index, MetadataIndex("st", [30]))
self.assertEqual(low_ri.storage_offsets, torch.Size([10]))
self.assertEqual(low_ri.dest_index, MetadataIndex("st", [40]))
self.assertEqual(low_ri.dest_offsets, torch.Size([0]))
self.assertEqual(low_ri.lengths, torch.Size([20]))
self.assertEqual(high_ri.storage_index, MetadataIndex("st", [60]))
self.assertEqual(high_ri.storage_offsets, torch.Size([0]))
self.assertEqual(high_ri.dest_index, MetadataIndex("st", [40]))
self.assertEqual(high_ri.dest_offsets, torch.Size([20]))
self.assertEqual(high_ri.lengths, torch.Size([20]))
if __name__ == "__main__":
run_tests()
|
def create_sharded_tensor(rank, world_size, shards_per_rank, shard_size=8):
shards_metadata = []
local_shards = []
for idx in range(0, world_size * shards_per_rank):
shard_rank = idx // shards_per_rank
shard_md = ShardMetadata(
shard_offsets=[idx * shard_size],
shard_sizes=[shard_size],
placement=f"rank:{shard_rank}/cpu",
)
shards_metadata.append(shard_md)
if shard_rank == rank:
shard = Shard.from_tensor_and_offsets(
torch.rand(*shard_md.shard_sizes),
shard_offsets=shard_md.shard_offsets,
rank=rank,
)
local_shards.append(shard)
sharded_tensor_md = ShardedTensorMetadata(
shards_metadata=shards_metadata,
size=torch.Size([shard_size * len(shards_metadata)]),
tensor_properties=TensorProperties_Shard.create_from_tensor(torch.zeros(1)),
)
return ShardedTensor._init_from_local_shards_and_global_metadata(
local_shards=local_shards, sharded_tensor_metadata=sharded_tensor_md
)
class TestSavePlan(TestCase):
@with_fake_comms(rank=1, world_size=4)
def test_local_plan(self):
tensor = torch.rand(10)
val = [1, 2, 3]
st = create_sharded_tensor(rank=1, world_size=4, shards_per_rank=1)
state_dict = {"tensor": tensor, "value": val, "st": st}
plan = create_default_local_save_plan(state_dict, False)
self.assertEqual(3, len(plan.items))
wi = plan.items[0]
self.assertEqual(wi.index, MetadataIndex("tensor", [0]))
self.assertEqual(wi.type, WriteItemType.TENSOR)
self.assertEqual(wi.tensor_data.size, tensor.size())
self.assertEqual(
wi.tensor_data.properties,
TensorProperties.create_from_tensor(torch.zeros(1)),
)
self.assertEqual(wi.tensor_data.chunk.offsets, torch.Size([0]))
self.assertEqual(wi.tensor_data.chunk.sizes, torch.Size([10]))
st_wi = plan.items[2]
self.assertEqual(st_wi.index, MetadataIndex("st", [8]))
self.assertEqual(st_wi.type, WriteItemType.SHARD)
self.assertEqual(st_wi.tensor_data.size, st.size())
self.assertEqual(
st_wi.tensor_data.properties,
TensorProperties.create_from_tensor(torch.zeros(1)),
)
self.assertEqual(st_wi.tensor_data.chunk.offsets, torch.Size([8]))
self.assertEqual(st_wi.tensor_data.chunk.sizes, torch.Size([8]))
# Coordinator rank, should include replicated items as well
plan = create_default_local_save_plan(state_dict, True)
self.assertEqual(3, len(plan.items))
tensor_wi = next(wi for wi in plan.items if wi.type == WriteItemType.TENSOR)
self.assertEqual(tensor_wi.index, MetadataIndex("tensor", [0]))
self.assertEqual(tensor_wi.tensor_data.size, tensor.size())
self.assertEqual(
tensor_wi.tensor_data.properties,
TensorProperties.create_from_tensor(tensor),
)
self.assertEqual(tensor_wi.tensor_data.chunk.offsets, torch.Size([0]))
self.assertEqual(tensor_wi.tensor_data.chunk.sizes, torch.Size([10]))
bytes_wi = next(wi for wi in plan.items if wi.type == WriteItemType.BYTE_IO)
self.assertEqual(bytes_wi.index, MetadataIndex("value"))
self.assertIsNone(bytes_wi.tensor_data)
def test_global_plan(self):
def create_data(rank):
with with_dist(rank=rank, world_size=4):
tensor = torch.rand(10)
val = [1, 2, 3]
st = create_sharded_tensor(rank=rank, world_size=4, shards_per_rank=1)
state_dict = {"tensor": tensor, "value": val, "st": st}
return create_default_local_save_plan(state_dict, rank == 0)
all_plans = [create_data(0), create_data(1), create_data(2), create_data(3)]
all_plans = dedup_save_plans(all_plans)
final_plans, metadata = create_default_global_save_plan(all_plans=all_plans)
# The default global plan updates all indexes to include hints
for new_plan, old_plan in zip(final_plans, all_plans):
for new_item, old_item in zip(new_plan.items, old_plan.items):
self.assertEqual(new_item.index, old_item.index)
self.assertEqual(new_item.type, old_item.type)
self.assertEqual(new_item.tensor_data, old_item.tensor_data)
self.assertIn(new_item.index.fqn, metadata.state_dict_metadata)
item_md = metadata.state_dict_metadata[new_item.index.fqn]
if new_item.type == WriteItemType.BYTE_IO:
self.assertTrue(isinstance(item_md, BytesStorageMetadata))
else:
self.assertTrue(isinstance(item_md, TensorStorageMetadata))
self.assertEqual(item_md.size, old_item.tensor_data.size)
self.assertEqual(
item_md.properties, old_item.tensor_data.properties
)
self.assertIsNotNone(new_item.index.index)
# Make sure the hint is correct
self.assertEqual(
item_md.chunks[new_item.index.index], old_item.tensor_data.chunk
)
def test_local_load_plan(self):
def create_state_dict(rank):
with with_dist(rank=rank, world_size=4):
tensor = torch.rand(10)
val = [1, 2, 3]
st = create_sharded_tensor(rank=rank, world_size=4, shards_per_rank=1)
return {"tensor": tensor, "value": val, "st": st}
state_dict = create_state_dict(1)
metadata = _create_default_local_metadata(state_dict)
load_plan = create_default_local_load_plan(state_dict, metadata)
# This will create 3 entries
self.assertEqual(3, len(load_plan.items))
st_item = next(ri for ri in load_plan.items if ri.dest_index.fqn == "st")
tensor_item = next(
ri for ri in load_plan.items if ri.dest_index.fqn == "tensor"
)
bytes_item = next(ri for ri in load_plan.items if ri.dest_index.fqn == "value")
self.assertEqual(st_item.type, LoadItemType.TENSOR)
# This is an exact copy
self.assertEqual(st_item.dest_index, MetadataIndex("st", [8]))
self.assertEqual(st_item.dest_offsets, torch.Size([0]))
self.assertEqual(st_item.storage_index, MetadataIndex("st", [8]))
self.assertEqual(st_item.storage_offsets, torch.Size([0]))
self.assertEqual(st_item.lengths, torch.Size([8]))
self.assertEqual(tensor_item.type, LoadItemType.TENSOR)
self.assertEqual(tensor_item.dest_index, MetadataIndex("tensor", [0]))
self.assertEqual(tensor_item.dest_offsets, torch.Size([0]))
self.assertEqual(tensor_item.storage_index, MetadataIndex("tensor", [0]))
self.assertEqual(tensor_item.storage_offsets, torch.Size([0]))
self.assertEqual(tensor_item.lengths, torch.Size([10]))
self.assertEqual(bytes_item.type, LoadItemType.BYTE_IO)
self.assertEqual(bytes_item.dest_index, MetadataIndex("value"))
def test_load_with_resharding(self):
def create_state_dict(rank, world_size):
with with_dist(rank=rank, world_size=world_size):
return {
"st": create_sharded_tensor(
rank=rank,
world_size=world_size,
shards_per_rank=1,
shard_size=128 // world_size,
)
}
# Rank 1 has a 16 bytes shard from [16, 32[
world8_state_dict = create_state_dict(rank=1, world_size=8)
world8_metadata = _create_default_local_metadata(world8_state_dict)
# Rank 1 has a 32 bytes shard from [32, 64[
world4_state_dict = create_state_dict(rank=1, world_size=4)
world4_metadata = _create_default_local_metadata(world4_state_dict)
# First scenario, going from world=8 to world=4, need to load 2 shards
# Each 4-world shard has 32 elements, so it needs to load 2 shards
load_plan = create_default_local_load_plan(world4_state_dict, world8_metadata)
self.assertEqual(2, len(load_plan.items))
low_ri = next(
ri for ri in load_plan.items if ri.dest_offsets == torch.Size([0])
)
high_ri = next(
ri for ri in load_plan.items if ri.dest_offsets == torch.Size([16])
)
self.assertEqual(low_ri.storage_index, MetadataIndex("st", [32]))
self.assertEqual(low_ri.storage_offsets, torch.Size([0]))
self.assertEqual(low_ri.dest_index, MetadataIndex("st", [32]))
self.assertEqual(low_ri.dest_offsets, torch.Size([0]))
self.assertEqual(low_ri.lengths, torch.Size([16]))
self.assertEqual(high_ri.storage_index, MetadataIndex("st", [48]))
self.assertEqual(high_ri.storage_offsets, torch.Size([0]))
self.assertEqual(high_ri.dest_index, MetadataIndex("st", [32]))
self.assertEqual(high_ri.dest_offsets, torch.Size([16]))
self.assertEqual(high_ri.lengths, torch.Size([16]))
# Second scenario, going from world=4 to world=8, need to load half of 1 shard
# rank1 on 8-world needs to load the upper half of the rank0 4-world shard
load_plan = create_default_local_load_plan(world8_state_dict, world4_metadata)
self.assertEqual(1, len(load_plan.items))
ri = load_plan.items[0]
self.assertEqual(ri.storage_index, MetadataIndex("st", [0]))
self.assertEqual(ri.storage_offsets, torch.Size([16]))
self.assertEqual(ri.dest_index, MetadataIndex("st", [16]))
self.assertEqual(ri.dest_offsets, torch.Size([0]))
self.assertEqual(ri.lengths, torch.Size([16]))
def test_load_with_world_size_diff_by_one(self):
def create_state_dict(rank, world_size):
with with_dist(rank=rank, world_size=world_size):
return {
"st": create_sharded_tensor(
rank=rank,
world_size=world_size,
shards_per_rank=1,
shard_size=120 // world_size,
)
}
# rank 1 has a 30 bytes shard from [30, 60[
world4_state_dict = create_state_dict(rank=1, world_size=4)
world4_metadata = _create_default_local_metadata(world4_state_dict)
# rank 1 has a 40 bytes shard from [40, 80[
world3_state_dict = create_state_dict(rank=1, world_size=3)
load_plan = create_default_local_load_plan(world3_state_dict, world4_metadata)
self.assertEqual(2, len(load_plan.items))
# this is [30, 60] to load [40, 60]
low_ri = next(
ri for ri in load_plan.items if ri.dest_offsets == torch.Size([0])
)
# this is [60, 90] to load [60, 80]
high_ri = next(
ri for ri in load_plan.items if ri.dest_offsets == torch.Size([20])
)
self.assertEqual(low_ri.storage_index, MetadataIndex("st", [30]))
self.assertEqual(low_ri.storage_offsets, torch.Size([10]))
self.assertEqual(low_ri.dest_index, MetadataIndex("st", [40]))
self.assertEqual(low_ri.dest_offsets, torch.Size([0]))
self.assertEqual(low_ri.lengths, torch.Size([20]))
self.assertEqual(high_ri.storage_index, MetadataIndex("st", [60]))
self.assertEqual(high_ri.storage_offsets, torch.Size([0]))
self.assertEqual(high_ri.dest_index, MetadataIndex("st", [40]))
self.assertEqual(high_ri.dest_offsets, torch.Size([20]))
self.assertEqual(high_ri.lengths, torch.Size([20]))
class TestPlannerHelpers(TestCase):
def test_create_read_item_from_chunks(self):
tensor_md = TensorStorageMetadata(
properties=TensorProperties.create_from_tensor(torch.empty([16])),
size=torch.Size([16]),
chunks=[
ChunkStorageMetadata(offsets=torch.Size([0]), sizes=torch.Size([8])),
ChunkStorageMetadata(offsets=torch.Size([8]), sizes=torch.Size([8])),
],
)
chunk = ChunkStorageMetadata(offsets=torch.Size([4]), sizes=torch.Size([7]))
read_items = create_read_items_for_chunk_list("foo", tensor_md, [chunk])
self.assertEqual(2, len(read_items))
self.assertEqual(MetadataIndex("foo", [4]), read_items[0].dest_index)
self.assertEqual(torch.Size([0]), read_items[0].dest_offsets)
self.assertEqual(MetadataIndex("foo", [0]), read_items[0].storage_index)
self.assertEqual(torch.Size([4]), read_items[0].storage_offsets)
self.assertEqual(torch.Size([4]), read_items[0].lengths)
self.assertEqual(MetadataIndex("foo", [4]), read_items[1].dest_index)
self.assertEqual(torch.Size([4]), read_items[1].dest_offsets)
self.assertEqual(MetadataIndex("foo", [8]), read_items[1].storage_index)
self.assertEqual(torch.Size([0]), read_items[1].storage_offsets)
self.assertEqual(torch.Size([3]), read_items[1].lengths)
class TestLoadPlanner(TestCase):
@with_temp_dir
def test_strict(self):
original_module = nn.Linear(2, 2)
dcp.save(state_dict={"module": original_module}, checkpoint_id=self.temp_dir)
new_module = nn.Linear(2, 2)
new_module.extra_param = nn.Parameter(torch.randn(2, 2))
dcp.load(
state_dict={"module": new_module},
checkpoint_id=self.temp_dir,
planner=DefaultLoadPlanner(allow_partial_load=True),
)
with self.assertRaisesRegex(CheckpointException, "Missing key in checkpoint"):
dcp.load(
state_dict={"module": new_module},
checkpoint_id=self.temp_dir,
planner=DefaultLoadPlanner(allow_partial_load=False),
)
if __name__ == "__main__":
run_tests()
|
import sys
import torch
from torch.distributed.checkpoint.planner import LoadItemType, WriteItemType
from torch.distributed._shard.sharded_tensor import (
Shard,
ShardMetadata,
ShardedTensor,
ShardedTensorMetadata,
)
from torch.distributed._shard.sharded_tensor.metadata import TensorProperties
from torch.testing._internal.common_utils import (
TestCase,
TEST_WITH_DEV_DBG_ASAN,
run_tests,
)
from torch.distributed.checkpoint.metadata import BytesStorageMetadata, MetadataIndex, TensorStorageMetadata
from torch.testing._internal.distributed.distributed_utils import (
with_fake_comms,
with_dist
)
from torch.distributed.checkpoint.default_planner import (
create_default_global_save_plan,
create_default_local_save_plan,
create_default_local_load_plan,
_create_default_local_metadata
)
|
import sys
import torch
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed._shard.sharded_tensor import (
Shard,
ShardedTensor,
ShardedTensorMetadata,
ShardMetadata,
)
from torch.distributed._shard.sharded_tensor.metadata import (
TensorProperties as TensorProperties_Shard,
)
from torch.distributed.checkpoint._dedup_save_plans import dedup_save_plans
from torch.distributed.checkpoint.api import CheckpointException
from torch.distributed.checkpoint.default_planner import (
_create_default_local_metadata,
create_default_global_save_plan,
create_default_local_load_plan,
create_default_local_save_plan,
DefaultLoadPlanner,
)
from torch.distributed.checkpoint.metadata import (
BytesStorageMetadata,
ChunkStorageMetadata,
MetadataIndex,
TensorProperties,
TensorStorageMetadata,
)
from torch.distributed.checkpoint.planner import LoadItemType, WriteItemType
from torch.distributed.checkpoint.planner_helpers import (
create_read_items_for_chunk_list,
)
from torch.testing._internal.common_utils import (
run_tests,
TEST_WITH_DEV_DBG_ASAN,
TestCase,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
from torch.testing._internal.distributed.distributed_utils import (
with_dist,
with_fake_comms,
)
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/checkpoint/test_planner.py
|
test_local_plan
|
def test_local_plan(self):
tensor = torch.rand(10)
val = [1, 2, 3]
st = create_sharded_tensor(rank=1, world_size=4, shards_per_rank=1)
state_dict = {
"tensor": tensor,
"value": val,
"st": st
}
plan = create_default_local_save_plan(state_dict, False)
self.assertEqual(1, len(plan.items))
wi = plan.items[0]
self.assertEqual(wi.index, MetadataIndex("st", [8]))
self.assertEqual(wi.type, WriteItemType.SHARD)
self.assertEqual(wi.tensor_data.size, st.size())
self.assertEqual(wi.tensor_data.properties, TensorProperties.create_from_tensor(torch.zeros(1)))
self.assertEqual(wi.tensor_data.chunk.offsets, torch.Size([8]))
self.assertEqual(wi.tensor_data.chunk.sizes, torch.Size([8]))
# Coordinator rank, should include replicated items as well
plan = create_default_local_save_plan(state_dict, True)
self.assertEqual(3, len(plan.items))
tensor_wi = next(wi for wi in plan.items if wi.type == WriteItemType.TENSOR)
self.assertEqual(tensor_wi.index, MetadataIndex("tensor", [0]))
self.assertEqual(tensor_wi.tensor_data.size, tensor.size())
self.assertEqual(tensor_wi.tensor_data.properties, TensorProperties.create_from_tensor(tensor))
self.assertEqual(tensor_wi.tensor_data.chunk.offsets, torch.Size([0]))
self.assertEqual(tensor_wi.tensor_data.chunk.sizes, torch.Size([10]))
bytes_wi = next(wi for wi in plan.items if wi.type == WriteItemType.BYTE_IO)
self.assertEqual(bytes_wi.index, MetadataIndex("value"))
self.assertIsNone(bytes_wi.tensor_data)
|
def test_local_plan(self):
tensor = torch.rand(10)
val = [1, 2, 3]
st = create_sharded_tensor(rank=1, world_size=4, shards_per_rank=1)
state_dict = {"tensor": tensor, "value": val, "st": st}
plan = create_default_local_save_plan(state_dict, False)
self.assertEqual(3, len(plan.items))
wi = plan.items[0]
self.assertEqual(wi.index, MetadataIndex("tensor", [0]))
self.assertEqual(wi.type, WriteItemType.TENSOR)
self.assertEqual(wi.tensor_data.size, tensor.size())
self.assertEqual(
wi.tensor_data.properties,
TensorProperties.create_from_tensor(torch.zeros(1)),
)
self.assertEqual(wi.tensor_data.chunk.offsets, torch.Size([0]))
self.assertEqual(wi.tensor_data.chunk.sizes, torch.Size([10]))
st_wi = plan.items[2]
self.assertEqual(st_wi.index, MetadataIndex("st", [8]))
self.assertEqual(st_wi.type, WriteItemType.SHARD)
self.assertEqual(st_wi.tensor_data.size, st.size())
self.assertEqual(
st_wi.tensor_data.properties,
TensorProperties.create_from_tensor(torch.zeros(1)),
)
self.assertEqual(st_wi.tensor_data.chunk.offsets, torch.Size([8]))
self.assertEqual(st_wi.tensor_data.chunk.sizes, torch.Size([8]))
# Coordinator rank, should include replicated items as well
plan = create_default_local_save_plan(state_dict, True)
self.assertEqual(3, len(plan.items))
tensor_wi = next(wi for wi in plan.items if wi.type == WriteItemType.TENSOR)
self.assertEqual(tensor_wi.index, MetadataIndex("tensor", [0]))
self.assertEqual(tensor_wi.tensor_data.size, tensor.size())
self.assertEqual(
tensor_wi.tensor_data.properties,
TensorProperties.create_from_tensor(tensor),
)
self.assertEqual(tensor_wi.tensor_data.chunk.offsets, torch.Size([0]))
self.assertEqual(tensor_wi.tensor_data.chunk.sizes, torch.Size([10]))
bytes_wi = next(wi for wi in plan.items if wi.type == WriteItemType.BYTE_IO)
self.assertEqual(bytes_wi.index, MetadataIndex("value"))
self.assertIsNone(bytes_wi.tensor_data)
|
import sys
import torch
from torch.distributed.checkpoint.planner import LoadItemType, WriteItemType
from torch.distributed._shard.sharded_tensor import (
Shard,
ShardMetadata,
ShardedTensor,
ShardedTensorMetadata,
)
from torch.distributed._shard.sharded_tensor.metadata import TensorProperties
from torch.testing._internal.common_utils import (
TestCase,
TEST_WITH_DEV_DBG_ASAN,
run_tests,
)
from torch.distributed.checkpoint.metadata import BytesStorageMetadata, MetadataIndex, TensorStorageMetadata
from torch.testing._internal.distributed.distributed_utils import (
with_fake_comms,
with_dist
)
from torch.distributed.checkpoint.default_planner import (
create_default_global_save_plan,
create_default_local_save_plan,
create_default_local_load_plan,
_create_default_local_metadata
)
class TestSavePlan(TestCase):
|
import sys
import torch
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed._shard.sharded_tensor import (
Shard,
ShardedTensor,
ShardedTensorMetadata,
ShardMetadata,
)
from torch.distributed._shard.sharded_tensor.metadata import (
TensorProperties as TensorProperties_Shard,
)
from torch.distributed.checkpoint._dedup_save_plans import dedup_save_plans
from torch.distributed.checkpoint.api import CheckpointException
from torch.distributed.checkpoint.default_planner import (
_create_default_local_metadata,
create_default_global_save_plan,
create_default_local_load_plan,
create_default_local_save_plan,
DefaultLoadPlanner,
)
from torch.distributed.checkpoint.metadata import (
BytesStorageMetadata,
ChunkStorageMetadata,
MetadataIndex,
TensorProperties,
TensorStorageMetadata,
)
from torch.distributed.checkpoint.planner import LoadItemType, WriteItemType
from torch.distributed.checkpoint.planner_helpers import (
create_read_items_for_chunk_list,
)
from torch.testing._internal.common_utils import (
run_tests,
TEST_WITH_DEV_DBG_ASAN,
TestCase,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
from torch.testing._internal.distributed.distributed_utils import (
with_dist,
with_fake_comms,
)
class TestSavePlan(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/checkpoint/test_planner.py
|
create_data
|
def create_data(rank):
with with_dist(rank=rank, world_size=4):
tensor = torch.rand(10)
val = [1, 2, 3]
st = create_sharded_tensor(rank=rank, world_size=4, shards_per_rank=1)
state_dict = {
"tensor": tensor,
"value": val,
"st": st
}
return create_default_local_save_plan(state_dict, rank == 0)
all_plans = [create_data(0), create_data(1), create_data(2), create_data(3)]
final_plans, metadata = create_default_global_save_plan(all_plans=all_plans)
# The default global plan updates all indexes to include hints
for new_plan, old_plan in zip(final_plans, all_plans):
for new_item, old_item in zip(new_plan.items, old_plan.items):
self.assertEqual(new_item.index, old_item.index)
self.assertEqual(new_item.type, old_item.type)
self.assertEqual(new_item.tensor_data, old_item.tensor_data)
self.assertIn(new_item.index.fqn, metadata.state_dict_metadata)
item_md = metadata.state_dict_metadata[new_item.index.fqn]
if new_item.type == WriteItemType.BYTE_IO:
self.assertTrue(isinstance(item_md, BytesStorageMetadata))
else:
self.assertTrue(isinstance(item_md, TensorStorageMetadata))
self.assertEqual(item_md.size, old_item.tensor_data.size)
self.assertEqual(item_md.properties, old_item.tensor_data.properties)
self.assertIsNotNone(new_item.index.index)
# Make sure the hint is correct
self.assertEqual(item_md.chunks[new_item.index.index], old_item.tensor_data.chunk)
|
def create_data(rank):
with with_dist(rank=rank, world_size=4):
tensor = torch.rand(10)
val = [1, 2, 3]
st = create_sharded_tensor(rank=rank, world_size=4, shards_per_rank=1)
state_dict = {"tensor": tensor, "value": val, "st": st}
return create_default_local_save_plan(state_dict, rank == 0)
all_plans = [create_data(0), create_data(1), create_data(2), create_data(3)]
all_plans = dedup_save_plans(all_plans)
final_plans, metadata = create_default_global_save_plan(all_plans=all_plans)
# The default global plan updates all indexes to include hints
for new_plan, old_plan in zip(final_plans, all_plans):
for new_item, old_item in zip(new_plan.items, old_plan.items):
self.assertEqual(new_item.index, old_item.index)
self.assertEqual(new_item.type, old_item.type)
self.assertEqual(new_item.tensor_data, old_item.tensor_data)
self.assertIn(new_item.index.fqn, metadata.state_dict_metadata)
item_md = metadata.state_dict_metadata[new_item.index.fqn]
if new_item.type == WriteItemType.BYTE_IO:
self.assertTrue(isinstance(item_md, BytesStorageMetadata))
else:
self.assertTrue(isinstance(item_md, TensorStorageMetadata))
self.assertEqual(item_md.size, old_item.tensor_data.size)
self.assertEqual(
item_md.properties, old_item.tensor_data.properties
)
self.assertIsNotNone(new_item.index.index)
# Make sure the hint is correct
self.assertEqual(
item_md.chunks[new_item.index.index], old_item.tensor_data.chunk
)
|
import sys
import torch
from torch.distributed.checkpoint.planner import LoadItemType, WriteItemType
from torch.distributed._shard.sharded_tensor import (
Shard,
ShardMetadata,
ShardedTensor,
ShardedTensorMetadata,
)
from torch.distributed._shard.sharded_tensor.metadata import TensorProperties
from torch.testing._internal.common_utils import (
TestCase,
TEST_WITH_DEV_DBG_ASAN,
run_tests,
)
from torch.distributed.checkpoint.metadata import BytesStorageMetadata, MetadataIndex, TensorStorageMetadata
from torch.testing._internal.distributed.distributed_utils import (
with_fake_comms,
with_dist
)
from torch.distributed.checkpoint.default_planner import (
create_default_global_save_plan,
create_default_local_save_plan,
create_default_local_load_plan,
_create_default_local_metadata
)
|
import sys
import torch
import torch.distributed.checkpoint as dcp
import torch.nn as nn
from torch.distributed._shard.sharded_tensor import (
Shard,
ShardedTensor,
ShardedTensorMetadata,
ShardMetadata,
)
from torch.distributed._shard.sharded_tensor.metadata import (
TensorProperties as TensorProperties_Shard,
)
from torch.distributed.checkpoint._dedup_save_plans import dedup_save_plans
from torch.distributed.checkpoint.api import CheckpointException
from torch.distributed.checkpoint.default_planner import (
_create_default_local_metadata,
create_default_global_save_plan,
create_default_local_load_plan,
create_default_local_save_plan,
DefaultLoadPlanner,
)
from torch.distributed.checkpoint.metadata import (
BytesStorageMetadata,
ChunkStorageMetadata,
MetadataIndex,
TensorProperties,
TensorStorageMetadata,
)
from torch.distributed.checkpoint.planner import LoadItemType, WriteItemType
from torch.distributed.checkpoint.planner_helpers import (
create_read_items_for_chunk_list,
)
from torch.testing._internal.common_utils import (
run_tests,
TEST_WITH_DEV_DBG_ASAN,
TestCase,
)
from torch.testing._internal.distributed.checkpoint_utils import with_temp_dir
from torch.testing._internal.distributed.distributed_utils import (
with_dist,
with_fake_comms,
)
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/checkpoint/test_traverse.py
|
collect_data
|
def collect_data(path, value):
nonlocal data
data[path] = value
_traverse.traverse_state_dict(state_dict, collect_data)
self.assertIn(("key0",), data)
self.assertEqual(data[("key0",)], 1)
self.assertIn(("key1",), data)
self.assertEqual(data[("key1",)], [1, 2])
self.assertIn(("key2",), data)
self.assertEqual(data[("key2",)], {1: 2, 2: 3})
self.assertIn(("key3",), data)
self.assertEqual(data[("key3",)], torch.tensor([1]))
|
def collect_data(path, value):
nonlocal data
data[path] = value
_traverse.traverse_state_dict(state_dict, collect_data)
self.assertIn(("key0",), data)
self.assertEqual(data[("key0",)], 1)
self.assertIn(("key1",), data)
self.assertEqual(data[("key1",)], [1, 2])
self.assertIn(("key2", "1"), data)
self.assertEqual(data[("key2", "1")], 2)
self.assertIn(("key2", "2"), data)
self.assertEqual(data[("key2", "2")], 3)
self.assertIn(("key3",), data)
self.assertEqual(data[("key3",)], torch.tensor([1]))
|
from collections import OrderedDict
import torch
import torch.distributed.checkpoint._traverse as _traverse
from torch.distributed.checkpoint.metadata import STATE_DICT_TYPE
from torch.testing._internal.common_utils import run_tests, TestCase
|
from collections import OrderedDict
from typing import TYPE_CHECKING
import torch
import torch.distributed.checkpoint._traverse as _traverse
from torch.testing._internal.common_utils import run_tests, TestCase
from torch.distributed.checkpoint.metadata import STATE_DICT_TYPE
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/checkpoint/test_traverse.py
|
collect_data
|
def collect_data(path, value):
nonlocal data
data[path] = value
_traverse.traverse_state_dict(state_dict, collect_data)
self.assertIn(("key0",), data)
self.assertEqual(data[("key0",)], 1)
self.assertIn(("key1",), data)
self.assertEqual(data[("key1",)], [1, 2])
self.assertIn(("key2",), data)
self.assertEqual(data[("key2",)], {1: 2, 2: 3})
self.assertIn(("key3",), data)
self.assertEqual(data[("key3",)], torch.tensor([1]))
|
def collect_data(path, value):
nonlocal data
data[path] = value
_traverse.traverse_state_dict(state_dict, collect_data)
self.assertIn(("key0",), data)
self.assertEqual(data[("key0",)], 1)
self.assertIn(("key1",), data)
self.assertEqual(data[("key1",)], [1, 2])
self.assertIn(("key2", "1"), data)
self.assertEqual(data[("key2", "1")], 2)
self.assertIn(("key2", "2"), data)
self.assertEqual(data[("key2", "2")], 3)
self.assertIn(("key3",), data)
self.assertEqual(data[("key3",)], torch.tensor([1]))
|
from collections import OrderedDict
import torch
import torch.distributed.checkpoint._traverse as _traverse
from torch.distributed.checkpoint.metadata import STATE_DICT_TYPE
from torch.testing._internal.common_utils import run_tests, TestCase
|
from collections import OrderedDict
from typing import TYPE_CHECKING
import torch
import torch.distributed.checkpoint._traverse as _traverse
from torch.testing._internal.common_utils import run_tests, TestCase
from torch.distributed.checkpoint.metadata import STATE_DICT_TYPE
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/checkpoint/test_traverse.py
|
collect_data
|
def collect_data(path, value):
nonlocal data
data[path] = value
_traverse.traverse_state_dict(state_dict, collect_data)
self.assertIn(("key0",), data)
self.assertEqual(data[("key0",)], 1)
self.assertIn(("key1",), data)
self.assertEqual(data[("key1",)], [1, 2])
self.assertIn(("key2",), data)
self.assertEqual(data[("key2",)], {1: 2, 2: 3})
self.assertIn(("key3",), data)
self.assertEqual(data[("key3",)], torch.tensor([1]))
|
def collect_data(path, value):
nonlocal data
data[path] = value
_traverse.traverse_state_dict(state_dict, collect_data)
self.assertIn(("key0",), data)
self.assertEqual(data[("key0",)], 1)
self.assertIn(("key1",), data)
self.assertEqual(data[("key1",)], [1, 2])
self.assertIn(("key2", "1"), data)
self.assertEqual(data[("key2", "1")], 2)
self.assertIn(("key2", "2"), data)
self.assertEqual(data[("key2", "2")], 3)
self.assertIn(("key3",), data)
self.assertEqual(data[("key3",)], torch.tensor([1]))
|
from collections import OrderedDict
import torch
import torch.distributed.checkpoint._traverse as _traverse
from torch.distributed.checkpoint.metadata import STATE_DICT_TYPE
from torch.testing._internal.common_utils import run_tests, TestCase
|
from collections import OrderedDict
from typing import TYPE_CHECKING
import torch
import torch.distributed.checkpoint._traverse as _traverse
from torch.testing._internal.common_utils import run_tests, TestCase
from torch.distributed.checkpoint.metadata import STATE_DICT_TYPE
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/checkpoint/test_traverse.py
|
collect_data
|
def collect_data(path, value):
nonlocal data
data[path] = value
_traverse.traverse_state_dict(state_dict, collect_data)
self.assertIn(("key0",), data)
self.assertEqual(data[("key0",)], 1)
self.assertIn(("key1",), data)
self.assertEqual(data[("key1",)], [1, 2])
self.assertIn(("key2",), data)
self.assertEqual(data[("key2",)], {1: 2, 2: 3})
self.assertIn(("key3",), data)
self.assertEqual(data[("key3",)], torch.tensor([1]))
|
def collect_data(path, value):
nonlocal data
data[path] = value
_traverse.traverse_state_dict(state_dict, collect_data)
self.assertIn(("key0",), data)
self.assertEqual(data[("key0",)], 1)
self.assertIn(("key1",), data)
self.assertEqual(data[("key1",)], [1, 2])
self.assertIn(("key2", "1"), data)
self.assertEqual(data[("key2", "1")], 2)
self.assertIn(("key2", "2"), data)
self.assertEqual(data[("key2", "2")], 3)
self.assertIn(("key3",), data)
self.assertEqual(data[("key3",)], torch.tensor([1]))
|
from collections import OrderedDict
import torch
import torch.distributed.checkpoint._traverse as _traverse
from torch.distributed.checkpoint.metadata import STATE_DICT_TYPE
from torch.testing._internal.common_utils import run_tests, TestCase
|
from collections import OrderedDict
from typing import TYPE_CHECKING
import torch
import torch.distributed.checkpoint._traverse as _traverse
from torch.testing._internal.common_utils import run_tests, TestCase
from torch.distributed.checkpoint.metadata import STATE_DICT_TYPE
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/checkpoint/test_utils.py
|
create_sharded_tensor
|
def create_sharded_tensor(rank, world_size, shards_per_rank):
shards_metadata = []
local_shards = []
for idx in range(0, world_size * shards_per_rank):
shard_rank = idx // shards_per_rank
shard_md = ShardMetadata(shard_offsets=[idx * 8], shard_sizes=[8], placement=f"rank:{shard_rank}/cpu")
shards_metadata.append(shard_md)
if shard_rank == rank:
shard = Shard.from_tensor_and_offsets(
torch.rand(*shard_md.shard_sizes),
shard_offsets=shard_md.shard_offsets,
rank=rank
)
local_shards.append(shard)
sharded_tensor_md = ShardedTensorMetadata(
shards_metadata=shards_metadata,
size=torch.Size([8 * len(shards_metadata)]),
tensor_properties=TensorProperties.create_from_tensor(torch.zeros(1))
)
return ShardedTensor._init_from_local_shards_and_global_metadata(
local_shards=local_shards,
sharded_tensor_metadata=sharded_tensor_md
)
class TestMedatadaIndex(TestCase):
def test_init_convert_offset(self):
a = MetadataIndex("foo", [1, 2])
b = MetadataIndex("foo", torch.Size([1, 2]))
self.assertEqual(a, b)
def test_index_hint_ignored_on_equals(self):
a = MetadataIndex("foo")
b = MetadataIndex("foo", index=99)
self.assertEqual(a, b)
def test_index_hint_ignored_on_hash(self):
a = MetadataIndex("foo")
b = MetadataIndex("foo", index=99)
self.assertEqual(hash(a), hash(b))
def test_flat_data(self):
state_dict = {
"a": torch.rand(10),
"b": [1, 2, 3],
}
a = find_state_dict_object(state_dict, MetadataIndex("a"))
self.assertEqual(a, state_dict["a"])
a = find_state_dict_object(state_dict, MetadataIndex("a", [0]))
self.assertEqual(a, state_dict["a"])
a = find_state_dict_object(state_dict, MetadataIndex("a", index=99))
self.assertEqual(a, state_dict["a"])
b = find_state_dict_object(state_dict, MetadataIndex("b"))
self.assertEqual(b, state_dict["b"])
b = find_state_dict_object(state_dict, MetadataIndex("b", index=1))
self.assertEqual(b, state_dict["b"])
with self.assertRaisesRegex(ValueError, "FQN"):
find_state_dict_object(state_dict, MetadataIndex("c"))
with self.assertRaisesRegex(ValueError, "ShardedTensor"):
find_state_dict_object(state_dict, MetadataIndex("b", [1]))
@with_fake_comms(rank=0, world_size=2)
def test_sharded_tensor_lookup(self):
st = create_sharded_tensor(rank=0, world_size=2, shards_per_rank=3)
state_dict = {"st": st}
obj = find_state_dict_object(state_dict, MetadataIndex("st", [8]))
self.assertEqual(obj, st.local_shards()[1].tensor)
# good hint
obj = find_state_dict_object(state_dict, MetadataIndex("st", [8], index=1))
self.assertEqual(obj, st.local_shards()[1].tensor)
# bad hint
obj = find_state_dict_object(state_dict, MetadataIndex("st", [8], index=2))
self.assertEqual(obj, st.local_shards()[1].tensor)
# broken hint
obj = find_state_dict_object(state_dict, MetadataIndex("st", [8], index=99))
self.assertEqual(obj, st.local_shards()[1].tensor)
with self.assertRaisesRegex(ValueError, "no offset was provided"):
find_state_dict_object(state_dict, MetadataIndex("st"))
with self.assertRaisesRegex(ValueError, "Could not find shard"):
find_state_dict_object(state_dict, MetadataIndex("st", [1]))
if __name__ == "__main__":
run_tests()
|
def create_sharded_tensor(rank, world_size, shards_per_rank):
shards_metadata = []
local_shards = []
for idx in range(0, world_size * shards_per_rank):
shard_rank = idx // shards_per_rank
shard_md = ShardMetadata(
shard_offsets=[idx * 8], shard_sizes=[8], placement=f"rank:{shard_rank}/cpu"
)
shards_metadata.append(shard_md)
if shard_rank == rank:
shard = Shard.from_tensor_and_offsets(
torch.rand(*shard_md.shard_sizes),
shard_offsets=shard_md.shard_offsets,
rank=rank,
)
local_shards.append(shard)
sharded_tensor_md = ShardedTensorMetadata(
shards_metadata=shards_metadata,
size=torch.Size([8 * len(shards_metadata)]),
tensor_properties=TensorProperties.create_from_tensor(torch.zeros(1)),
)
return ShardedTensor._init_from_local_shards_and_global_metadata(
local_shards=local_shards, sharded_tensor_metadata=sharded_tensor_md
)
class TestMedatadaIndex(TestCase):
def test_init_convert_offset(self):
a = MetadataIndex("foo", [1, 2])
b = MetadataIndex("foo", torch.Size([1, 2]))
self.assertEqual(a, b)
def test_index_hint_ignored_on_equals(self):
a = MetadataIndex("foo")
b = MetadataIndex("foo", index=99)
self.assertEqual(a, b)
def test_index_hint_ignored_on_hash(self):
a = MetadataIndex("foo")
b = MetadataIndex("foo", index=99)
self.assertEqual(hash(a), hash(b))
def test_flat_data(self):
state_dict = {
"a": torch.rand(10),
"b": [1, 2, 3],
}
a = find_state_dict_object(state_dict, MetadataIndex("a"))
self.assertEqual(a, state_dict["a"])
a = find_state_dict_object(state_dict, MetadataIndex("a", [0]))
self.assertEqual(a, state_dict["a"])
a = find_state_dict_object(state_dict, MetadataIndex("a", index=99))
self.assertEqual(a, state_dict["a"])
b = find_state_dict_object(state_dict, MetadataIndex("b"))
self.assertEqual(b, state_dict["b"])
b = find_state_dict_object(state_dict, MetadataIndex("b", index=1))
self.assertEqual(b, state_dict["b"])
with self.assertRaisesRegex(ValueError, "FQN"):
find_state_dict_object(state_dict, MetadataIndex("c"))
with self.assertRaisesRegex(ValueError, "ShardedTensor"):
find_state_dict_object(state_dict, MetadataIndex("b", [1]))
@with_fake_comms(rank=0, world_size=2)
def test_sharded_tensor_lookup(self):
st = create_sharded_tensor(rank=0, world_size=2, shards_per_rank=3)
state_dict = {"st": st}
obj = find_state_dict_object(state_dict, MetadataIndex("st", [8]))
self.assertEqual(obj, st.local_shards()[1].tensor)
# good hint
obj = find_state_dict_object(state_dict, MetadataIndex("st", [8], index=1))
self.assertEqual(obj, st.local_shards()[1].tensor)
# bad hint
obj = find_state_dict_object(state_dict, MetadataIndex("st", [8], index=2))
self.assertEqual(obj, st.local_shards()[1].tensor)
# broken hint
obj = find_state_dict_object(state_dict, MetadataIndex("st", [8], index=99))
self.assertEqual(obj, st.local_shards()[1].tensor)
with self.assertRaisesRegex(ValueError, "no offset was provided"):
find_state_dict_object(state_dict, MetadataIndex("st"))
with self.assertRaisesRegex(ValueError, "Could not find shard"):
find_state_dict_object(state_dict, MetadataIndex("st", [1]))
def test_dcp_logger(self):
self.assertTrue(_c10d_logger is not _dcp_logger)
self.assertEqual(1, len(_c10d_logger.handlers))
if __name__ == "__main__":
run_tests()
|
import sys
import torch
from torch.distributed._shard.sharded_tensor import (
Shard,
ShardMetadata,
ShardedTensor,
ShardedTensorMetadata,
)
from torch.distributed._shard.sharded_tensor.metadata import TensorProperties
from torch.testing._internal.common_utils import (
TestCase,
TEST_WITH_DEV_DBG_ASAN,
run_tests,
)
from torch.distributed.checkpoint.utils import find_state_dict_object
from torch.distributed.checkpoint.metadata import MetadataIndex
from torch.testing._internal.distributed.distributed_utils import (
with_fake_comms
)
|
import sys
import torch
from torch.distributed._shard.sharded_tensor import (
Shard,
ShardedTensor,
ShardedTensorMetadata,
ShardMetadata,
)
from torch.distributed._shard.sharded_tensor.metadata import TensorProperties
from torch.distributed.c10d_logger import _c10d_logger
from torch.distributed.checkpoint.logger import _dcp_logger
from torch.distributed.checkpoint.metadata import MetadataIndex
from torch.distributed.checkpoint.utils import find_state_dict_object
from torch.testing._internal.common_utils import (
run_tests,
TEST_WITH_DEV_DBG_ASAN,
TestCase,
)
from torch.testing._internal.distributed.distributed_utils import with_fake_comms
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/agent/server/test/api_test.py
|
test_get_ranks
|
def test_get_ranks(self):
role_infos = [
_RoleInstanceInfo("parameter_server", 0, 4),
_RoleInstanceInfo("trainer", 1, 1),
_RoleInstanceInfo("trainer", 2, 2),
_RoleInstanceInfo("trainer", 3, 3),
_RoleInstanceInfo("parameter_server", 4, 5),
]
spec = self._get_worker_spec(
max_restarts=3, monitor_interval=0.1, role="not_used", local_world_size=8
)
agent = TestAgent(spec)
total_sum, ranks = agent._get_ranks(role_infos, 0, 0, len(role_infos))
self.assertEqual(15, total_sum)
self.assertEqual([0, 1, 2, 3], list(ranks))
|
import signal
import unittest
import uuid
from typing import Any, Dict
from unittest.mock import call, patch, MagicMock
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
RunResult,
SimpleElasticAgent,
WorkerGroup,
WorkerSpec,
WorkerState,
_get_fq_hostname,
_RoleInstanceInfo,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
class SimpleElasticAgentTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
deleted
|
||
torch
|
test/distributed/elastic/agent/server/test/api_test.py
|
test_assign_worker_ranks
|
def test_assign_worker_ranks(self):
role_infos = [
_RoleInstanceInfo("parameter_server", 0, 4),
_RoleInstanceInfo("trainer", 1, 1),
_RoleInstanceInfo("trainer", 2, 2),
_RoleInstanceInfo("trainer", 3, 3),
_RoleInstanceInfo("parameter_server", 4, 5),
]
num_agents = len(role_infos)
with patch.object(TestAgent, "_share_and_gather", return_value=role_infos):
self.verify_worker_ranks(
role_infos[0], num_agents, [0, 1, 2, 3], [0, 1, 2, 3]
)
self.verify_worker_ranks(role_infos[1], num_agents, [4], [0])
self.verify_worker_ranks(role_infos[2], num_agents, [5, 6], [1, 2])
self.verify_worker_ranks(role_infos[3], num_agents, [7, 8, 9], [3, 4, 5])
|
def test_assign_worker_ranks(self):
role_infos = [
_RoleInstanceInfo("parameter_server", 0, 4),
_RoleInstanceInfo("trainer", 1, 1),
_RoleInstanceInfo("trainer", 2, 2),
_RoleInstanceInfo("trainer", 3, 3),
_RoleInstanceInfo("parameter_server", 4, 5),
]
store = dist.HashStore()
def f(info) -> List[Worker]:
i, role_info = info
spec = self._get_worker_spec(
max_restarts=3,
monitor_interval=0.1,
role=role_info.role,
local_world_size=role_info.local_world_size,
)
agent = TestAgent(spec)
workers = agent._assign_worker_ranks(
store, role_info.rank, len(role_infos), spec
)
return [
(
w.local_rank,
w.role_rank,
w.global_rank,
w.world_size,
w.role_world_size,
)
for w in workers
]
with ThreadPool(len(role_infos)) as pool:
out = pool.map(f, enumerate(role_infos))
self.assertListEqual(
out,
[
[
(0, 0, 0, 15, 9),
(1, 1, 1, 15, 9),
(2, 2, 2, 15, 9),
(3, 3, 3, 15, 9),
],
[
(0, 0, 4, 15, 6),
],
[
(0, 1, 5, 15, 6),
(1, 2, 6, 15, 6),
],
[
(0, 3, 7, 15, 6),
(1, 4, 8, 15, 6),
(2, 5, 9, 15, 6),
],
[
(0, 4, 10, 15, 9),
(1, 5, 11, 15, 9),
(2, 6, 12, 15, 9),
(3, 7, 13, 15, 9),
(4, 8, 14, 15, 9),
],
],
)
|
import signal
import unittest
import uuid
from typing import Any, Dict
from unittest.mock import call, patch, MagicMock
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
RunResult,
SimpleElasticAgent,
WorkerGroup,
WorkerSpec,
WorkerState,
_get_fq_hostname,
_RoleInstanceInfo,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
class SimpleElasticAgentTest(unittest.TestCase):
|
import signal
import unittest
import uuid
from multiprocessing.pool import ThreadPool
from typing import Any, Dict, List
from unittest.mock import call, patch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
_get_fq_hostname,
_RoleInstanceInfo,
RunResult,
SimpleElasticAgent,
Worker,
WorkerGroup,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.rendezvous.api import RendezvousGracefulExitError
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
class SimpleElasticAgentTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/agent/server/test/api_test.py
|
test_rendezvous
|
def test_rendezvous(self):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._rendezvous(worker_group)
# single agent rdzv
self.assertEqual(1, worker_group.group_world_size)
self.assertEqual(0, worker_group.group_rank)
master_addr, master_port = agent._get_master_addr_port(worker_group.store)
self.assertEqual(_get_fq_hostname(), master_addr)
self.assertTrue(master_port > 0)
rank_set = {w.global_rank for w in worker_group.workers}
for w in worker_group.workers:
self.assertIsNone(w.id)
local_world_size = spec.local_world_size
group_world_size = worker_group.group_world_size
group_rank = worker_group.group_rank
self.assertEqual(local_world_size * group_world_size, w.world_size)
self.assertEqual(
local_world_size * group_rank + w.local_rank, w.global_rank
)
self.assertSetEqual(set(range(w.world_size)), rank_set)
|
def test_rendezvous(self):
hostname = _get_fq_hostname()
spec = self._get_worker_spec(max_restarts=1, local_addr=hostname)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._rendezvous(worker_group)
# single agent rdzv
self.assertEqual(1, worker_group.group_world_size)
self.assertEqual(0, worker_group.group_rank)
self.assertEqual(hostname, worker_group.master_addr)
self.assertTrue(worker_group.master_port > 0)
rank_set = {w.global_rank for w in worker_group.workers}
for w in worker_group.workers:
self.assertIsNone(w.id)
local_world_size = spec.local_world_size
group_world_size = worker_group.group_world_size
group_rank = worker_group.group_rank
self.assertEqual(local_world_size * group_world_size, w.world_size)
self.assertEqual(
local_world_size * group_rank + w.local_rank, w.global_rank
)
self.assertSetEqual(set(range(w.world_size)), rank_set)
|
import signal
import unittest
import uuid
from typing import Any, Dict
from unittest.mock import call, patch, MagicMock
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
RunResult,
SimpleElasticAgent,
WorkerGroup,
WorkerSpec,
WorkerState,
_get_fq_hostname,
_RoleInstanceInfo,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
class SimpleElasticAgentTest(unittest.TestCase):
|
import signal
import unittest
import uuid
from multiprocessing.pool import ThreadPool
from typing import Any, Dict, List
from unittest.mock import call, patch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
_get_fq_hostname,
_RoleInstanceInfo,
RunResult,
SimpleElasticAgent,
Worker,
WorkerGroup,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.rendezvous.api import RendezvousGracefulExitError
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
class SimpleElasticAgentTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/agent/server/test/api_test.py
|
test_rendezvous_default_master_addr
|
def test_rendezvous_default_master_addr(self):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._rendezvous(worker_group)
master_addr, master_port = agent._get_master_addr_port(worker_group.store)
self.assertEqual(_get_fq_hostname(), master_addr)
self.assertGreater(master_port, 0)
|
def test_rendezvous_default_master_addr(self):
hostname = _get_fq_hostname()
spec = self._get_worker_spec(max_restarts=1, local_addr=hostname)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._rendezvous(worker_group)
self.assertEqual(_get_fq_hostname(), worker_group.master_addr)
self.assertGreater(worker_group.master_port, 0)
|
import signal
import unittest
import uuid
from typing import Any, Dict
from unittest.mock import call, patch, MagicMock
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
RunResult,
SimpleElasticAgent,
WorkerGroup,
WorkerSpec,
WorkerState,
_get_fq_hostname,
_RoleInstanceInfo,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
class SimpleElasticAgentTest(unittest.TestCase):
|
import signal
import unittest
import uuid
from multiprocessing.pool import ThreadPool
from typing import Any, Dict, List
from unittest.mock import call, patch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
_get_fq_hostname,
_RoleInstanceInfo,
RunResult,
SimpleElasticAgent,
Worker,
WorkerGroup,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.rendezvous.api import RendezvousGracefulExitError
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
class SimpleElasticAgentTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/agent/server/test/api_test.py
|
test_rendezvous_master_addr_with_local_addr
|
def test_rendezvous_master_addr_with_local_addr(self):
spec_local_addr = "1.2.3.4"
spec = self._get_worker_spec(max_restarts=1, local_addr=spec_local_addr)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._rendezvous(worker_group)
master_addr, master_port = agent._get_master_addr_port(worker_group.store)
self.assertNotEqual(_get_fq_hostname(), master_addr)
self.assertEqual(spec_local_addr, master_addr)
self.assertGreater(master_port, 0)
|
def test_rendezvous_master_addr_with_local_addr(self):
spec_local_addr = "127.0.0.1"
spec = self._get_worker_spec(max_restarts=1, local_addr=spec_local_addr)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._rendezvous(worker_group)
self.assertNotEqual(_get_fq_hostname(), worker_group.master_addr)
self.assertEqual(spec_local_addr, worker_group.master_addr)
self.assertGreater(worker_group.master_port, 0)
|
import signal
import unittest
import uuid
from typing import Any, Dict
from unittest.mock import call, patch, MagicMock
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
RunResult,
SimpleElasticAgent,
WorkerGroup,
WorkerSpec,
WorkerState,
_get_fq_hostname,
_RoleInstanceInfo,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
class SimpleElasticAgentTest(unittest.TestCase):
|
import signal
import unittest
import uuid
from multiprocessing.pool import ThreadPool
from typing import Any, Dict, List
from unittest.mock import call, patch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
_get_fq_hostname,
_RoleInstanceInfo,
RunResult,
SimpleElasticAgent,
Worker,
WorkerGroup,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.rendezvous.api import RendezvousGracefulExitError
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
class SimpleElasticAgentTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/agent/server/test/api_test.py
|
test_agent_process_handler_graceful_exception
|
if __name__ == "__main__":
run_tests()
|
def test_agent_process_handler_graceful_exception(self, invoke_run, _):
spec = self._get_worker_spec(max_restarts=0)
agent = TestAgent(spec)
invoke_run.side_effect = RendezvousGracefulExitError()
with patch.object(agent, "_shutdown"):
agent.run()
|
import signal
import unittest
import uuid
from multiprocessing.pool import ThreadPool
from typing import Any, Dict, List
from unittest.mock import call, patch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
_get_fq_hostname,
_RoleInstanceInfo,
RunResult,
SimpleElasticAgent,
Worker,
WorkerGroup,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.rendezvous.api import RendezvousGracefulExitError
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
class SimpleElasticAgentTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
|
torch
|
test/distributed/elastic/agent/server/test/local_elastic_agent_test.py
|
_bipolar_sleep_function
|
def _bipolar_sleep_function(sleep_sec):
rank = int(os.environ["RANK"])
if rank % 2 == 0:
_sleep(sleep_sec)
else:
_sad_function()
|
import json
import multiprocessing as mp
import os
import shutil
import signal
import socket
import tempfile
import time
import unittest
import uuid
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Tuple
from unittest import mock
from unittest.mock import Mock, patch
import torch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
import torch.distributed.rpc as rpc
from torch.distributed.elastic.agent.server.api import (
RunResult,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.agent.server.local_elastic_agent import (
LocalElasticAgent,
TORCHELASTIC_HEALTH_CHECK_PORT,
TORCHELASTIC_TIMER_FILE,
)
from torch.distributed.elastic.multiprocessing import DefaultLogsSpecs, Std
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError, record
from torch.distributed.elastic.rendezvous import RendezvousParameters
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.rpc.backend_registry import BackendType
from torch.testing._internal.common_utils import (
skip_but_pass_in_sandcastle_if,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
)
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/checkpoint/test_utils.py
|
test_dcp_logger
|
if __name__ == "__main__":
run_tests()
|
def test_dcp_logger(self):
self.assertTrue(_c10d_logger is not _dcp_logger)
self.assertEqual(1, len(_c10d_logger.handlers))
|
import sys
import torch
from torch.distributed._shard.sharded_tensor import (
Shard,
ShardedTensor,
ShardedTensorMetadata,
ShardMetadata,
)
from torch.distributed._shard.sharded_tensor.metadata import TensorProperties
from torch.distributed.c10d_logger import _c10d_logger
from torch.distributed.checkpoint.logger import _dcp_logger
from torch.distributed.checkpoint.metadata import MetadataIndex
from torch.distributed.checkpoint.utils import find_state_dict_object
from torch.testing._internal.common_utils import (
run_tests,
TEST_WITH_DEV_DBG_ASAN,
TestCase,
)
from torch.testing._internal.distributed.distributed_utils import with_fake_comms
class TestMedatadaIndex(TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
|
torch
|
test/distributed/elastic/agent/server/test/api_test.py
|
do_nothing
|
def do_nothing():
pass
class WorkerStateTest(unittest.TestCase):
def test_is_running(self):
for state in WorkerState:
if state == WorkerState.HEALTHY or state == WorkerState.UNHEALTHY:
self.assertTrue(WorkerState.is_running(state))
else:
self.assertFalse(WorkerState.is_running(state))
class WorkerGroupTest(unittest.TestCase):
def test_worker_group_constructor(self):
spec = WorkerSpec(
role="test_trainer",
local_world_size=4,
fn=do_nothing,
args=(),
rdzv_handler=None,
max_restarts=50,
monitor_interval=1,
)
worker_group = WorkerGroup(spec)
self.assertEqual(WorkerState.INIT, worker_group.state)
workers = worker_group.workers
self.assertEqual(4, len(workers))
# validate full, consecutive local ranks
self.assertSetEqual(set(range(4)), {w.local_rank for w in workers})
# global_rank, world_size are assigned after rdzv
# id is assigned after starting worker (by the agent)
# validate there are None
for w in workers:
self.assertEqual(-1, w.global_rank)
self.assertEqual(-1, w.world_size)
self.assertEqual(None, w.id)
# rank and store are assigned after rdzv; validate that they are None
self.assertIsNone(worker_group.group_rank)
self.assertIsNone(worker_group.store)
class RoleInstanceInfoTest(unittest.TestCase):
def test_compare(self):
agent_role1 = _RoleInstanceInfo("role", 1, 10)
agent_role2 = _RoleInstanceInfo("role", 2, 10)
self.assertEqual(1, _RoleInstanceInfo.compare(agent_role2, agent_role1))
agent_role1 = _RoleInstanceInfo("role1", 1, 10)
agent_role2 = _RoleInstanceInfo("role2", 2, 10)
self.assertEqual(-1, _RoleInstanceInfo.compare(agent_role1, agent_role2))
agent_role1 = _RoleInstanceInfo("role1", 1, 10)
agent_role2 = _RoleInstanceInfo("role2", 1, 10)
self.assertEqual(-1, _RoleInstanceInfo.compare(agent_role1, agent_role2))
def test_serde(self):
agent_role = _RoleInstanceInfo("role", 1, 10)
str_data = agent_role.serialize()
actual_agent_role = _RoleInstanceInfo.deserialize(str_data)
self.assertEqual(agent_role.role, actual_agent_role.role)
self.assertEqual(agent_role.rank, actual_agent_role.rank)
self.assertEqual(
agent_role.local_world_size, actual_agent_role.local_world_size
)
def test_find_boundaries(self):
role_infos = [
_RoleInstanceInfo("trainer", 1, 1),
_RoleInstanceInfo("trainer", 2, 2),
_RoleInstanceInfo("trainer", 3, 3),
_RoleInstanceInfo("parameter_server", 4, 5),
_RoleInstanceInfo("parameter_server", 0, 4),
]
start_idx, end_idx = _RoleInstanceInfo.find_role_boundaries(
role_infos, "trainer"
)
self.assertEqual(start_idx, 0)
self.assertEqual(end_idx, 2)
class TestAgent(SimpleElasticAgent):
def __init__(self, spec):
super().__init__(spec)
self.stop_workers_call_count = 0
self.start_workers_call_count = 0
def _stop_workers(self, worker_group: WorkerGroup) -> None:
# workers are fake, nothing to stop; just clear the rdzv info
worker_group.group_rank = None
worker_group.group_world_size = None
self.stop_workers_call_count += 1
def _start_workers(self, worker_group: WorkerGroup) -> Dict[int, Any]:
# crate fake workers; make worker id equal to global rank
ids = {}
for worker in worker_group.workers:
ids[worker.local_rank] = worker.global_rank
self.start_workers_call_count += 1
return ids
def _monitor_workers(self, worker_group: WorkerGroup) -> RunResult:
raise NotImplementedError("mock this method")
def _shutdown(self):
pass
|
def do_nothing():
pass
class WorkerStateTest(unittest.TestCase):
def test_is_running(self):
for state in WorkerState:
if state == WorkerState.HEALTHY or state == WorkerState.UNHEALTHY:
self.assertTrue(WorkerState.is_running(state))
else:
self.assertFalse(WorkerState.is_running(state))
class WorkerGroupTest(unittest.TestCase):
def test_worker_group_constructor(self):
spec = WorkerSpec(
role="test_trainer",
local_world_size=4,
fn=do_nothing,
args=(),
rdzv_handler=None,
max_restarts=50,
monitor_interval=0.1,
)
worker_group = WorkerGroup(spec)
self.assertEqual(WorkerState.INIT, worker_group.state)
workers = worker_group.workers
self.assertEqual(4, len(workers))
# validate full, consecutive local ranks
self.assertSetEqual(set(range(4)), {w.local_rank for w in workers})
# global_rank, world_size are assigned after rdzv
# id is assigned after starting worker (by the agent)
# validate there are None
for w in workers:
self.assertEqual(-1, w.global_rank)
self.assertEqual(-1, w.world_size)
self.assertEqual(None, w.id)
# rank and store are assigned after rdzv; validate that they are None
self.assertIsNone(worker_group.group_rank)
self.assertIsNone(worker_group.store)
class RoleInstanceInfoTest(unittest.TestCase):
def test_compare(self):
agent_role1 = _RoleInstanceInfo("role", 1, 10)
agent_role2 = _RoleInstanceInfo("role", 2, 10)
self.assertEqual(1, _RoleInstanceInfo.compare(agent_role2, agent_role1))
agent_role1 = _RoleInstanceInfo("role1", 1, 10)
agent_role2 = _RoleInstanceInfo("role2", 2, 10)
self.assertEqual(-1, _RoleInstanceInfo.compare(agent_role1, agent_role2))
agent_role1 = _RoleInstanceInfo("role1", 1, 10)
agent_role2 = _RoleInstanceInfo("role2", 1, 10)
self.assertEqual(-1, _RoleInstanceInfo.compare(agent_role1, agent_role2))
def test_serde(self):
agent_role = _RoleInstanceInfo("role", 1, 10)
str_data = agent_role.serialize()
actual_agent_role = _RoleInstanceInfo.deserialize(str_data)
self.assertEqual(agent_role.role, actual_agent_role.role)
self.assertEqual(agent_role.rank, actual_agent_role.rank)
self.assertEqual(
agent_role.local_world_size, actual_agent_role.local_world_size
)
def test_find_boundaries(self):
role_infos = [
_RoleInstanceInfo("trainer", 1, 1),
_RoleInstanceInfo("trainer", 2, 2),
_RoleInstanceInfo("trainer", 3, 3),
_RoleInstanceInfo("parameter_server", 4, 5),
_RoleInstanceInfo("parameter_server", 0, 4),
]
start_idx, end_idx = _RoleInstanceInfo.find_role_boundaries(
role_infos, "trainer"
)
self.assertEqual(start_idx, 0)
self.assertEqual(end_idx, 2)
class TestAgent(SimpleElasticAgent):
def __init__(self, spec):
super().__init__(spec)
self.stop_workers_call_count = 0
self.start_workers_call_count = 0
def _stop_workers(
self, worker_group: WorkerGroup, is_restart: bool = False
) -> None:
# workers are fake, nothing to stop; just clear the rdzv info
worker_group.group_rank = None
worker_group.group_world_size = None
self.stop_workers_call_count += 1
def _start_workers(self, worker_group: WorkerGroup) -> Dict[int, Any]:
# crate fake workers; make worker id equal to global rank
ids = {}
for worker in worker_group.workers:
ids[worker.local_rank] = worker.global_rank
self.start_workers_call_count += 1
return ids
def _monitor_workers(self, worker_group: WorkerGroup) -> RunResult:
raise NotImplementedError("mock this method")
def _shutdown(self):
pass
|
import signal
import unittest
import uuid
from typing import Any, Dict
from unittest.mock import call, patch, MagicMock
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
RunResult,
SimpleElasticAgent,
WorkerGroup,
WorkerSpec,
WorkerState,
_get_fq_hostname,
_RoleInstanceInfo,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
|
import signal
import unittest
import uuid
from multiprocessing.pool import ThreadPool
from typing import Any, Dict, List
from unittest.mock import call, patch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
_get_fq_hostname,
_RoleInstanceInfo,
RunResult,
SimpleElasticAgent,
Worker,
WorkerGroup,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.rendezvous.api import RendezvousGracefulExitError
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/agent/server/test/api_test.py
|
test_worker_group_constructor
|
def test_worker_group_constructor(self):
spec = WorkerSpec(
role="test_trainer",
local_world_size=4,
fn=do_nothing,
args=(),
rdzv_handler=None,
max_restarts=50,
monitor_interval=1,
)
worker_group = WorkerGroup(spec)
self.assertEqual(WorkerState.INIT, worker_group.state)
workers = worker_group.workers
self.assertEqual(4, len(workers))
# validate full, consecutive local ranks
self.assertSetEqual(set(range(4)), {w.local_rank for w in workers})
# global_rank, world_size are assigned after rdzv
# id is assigned after starting worker (by the agent)
# validate there are None
for w in workers:
self.assertEqual(-1, w.global_rank)
self.assertEqual(-1, w.world_size)
self.assertEqual(None, w.id)
# rank and store are assigned after rdzv; validate that they are None
self.assertIsNone(worker_group.group_rank)
self.assertIsNone(worker_group.store)
|
def test_worker_group_constructor(self):
spec = WorkerSpec(
role="test_trainer",
local_world_size=4,
fn=do_nothing,
args=(),
rdzv_handler=None,
max_restarts=50,
monitor_interval=0.1,
)
worker_group = WorkerGroup(spec)
self.assertEqual(WorkerState.INIT, worker_group.state)
workers = worker_group.workers
self.assertEqual(4, len(workers))
# validate full, consecutive local ranks
self.assertSetEqual(set(range(4)), {w.local_rank for w in workers})
# global_rank, world_size are assigned after rdzv
# id is assigned after starting worker (by the agent)
# validate there are None
for w in workers:
self.assertEqual(-1, w.global_rank)
self.assertEqual(-1, w.world_size)
self.assertEqual(None, w.id)
# rank and store are assigned after rdzv; validate that they are None
self.assertIsNone(worker_group.group_rank)
self.assertIsNone(worker_group.store)
|
import signal
import unittest
import uuid
from typing import Any, Dict
from unittest.mock import call, patch, MagicMock
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
RunResult,
SimpleElasticAgent,
WorkerGroup,
WorkerSpec,
WorkerState,
_get_fq_hostname,
_RoleInstanceInfo,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
class WorkerGroupTest(unittest.TestCase):
|
import signal
import unittest
import uuid
from multiprocessing.pool import ThreadPool
from typing import Any, Dict, List
from unittest.mock import call, patch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
_get_fq_hostname,
_RoleInstanceInfo,
RunResult,
SimpleElasticAgent,
Worker,
WorkerGroup,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.rendezvous.api import RendezvousGracefulExitError
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
class WorkerGroupTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/agent/server/test/api_test.py
|
monres
|
def monres(state: WorkerState):
if state == WorkerState.SUCCEEDED:
return RunResult(state=state, return_values={0: 0}, failures={})
elif state in {WorkerState.UNHEALTHY, WorkerState.FAILED}:
pf = ProcessFailure(local_rank=0, pid=999, exitcode=1, error_file="<none>")
return RunResult(state=state, return_values={}, failures={0: pf})
else:
return RunResult(state=state)
class SimpleElasticAgentTest(unittest.TestCase):
def _get_worker_spec(
self,
max_restarts=1,
monitor_interval=1.0,
role="test_trainer",
local_world_size=8,
local_addr=None,
):
run_id = str(uuid.uuid4().int)
port = get_free_port()
endpoint = f"127.0.0.1:{port}"
rdzv_params = RendezvousParameters(
backend="static",
endpoint=endpoint,
run_id=run_id,
min_nodes=1,
max_nodes=1,
rank=0,
)
rdzv_handler = rdzv_registry.get_rendezvous_handler(rdzv_params)
spec = WorkerSpec(
role=role,
local_world_size=local_world_size,
fn=do_nothing,
args=(),
rdzv_handler=rdzv_handler,
max_restarts=max_restarts,
monitor_interval=monitor_interval,
local_addr=local_addr,
)
return spec
def test_agent_constructor(self):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
self.assertEqual(WorkerState.INIT, worker_group.state)
self.assertEqual(spec.max_restarts, agent._remaining_restarts)
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_flakiness_metric(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
agent._record_flakiness_metric()
put_metric_mock.assert_called_with("workers.test_trainer.flakiness", 0)
agent._worker_group.spec.max_restarts = 10
agent._remaining_restarts = 3
agent._record_flakiness_metric()
put_metric_mock.assert_called_with("workers.test_trainer.flakiness", 63)
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_flakiness_metric_zero_restarts(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=1)
spec.max_restarts = 0
agent = TestAgent(spec)
agent._record_flakiness_metric()
put_metric_mock.assert_called_with("workers.test_trainer.flakiness", 0)
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_flakiness_metric_user_exception(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
agent._record_flakiness_metric(True)
put_metric_mock.assert_called_with("workers.test_trainer.flakiness", 100)
@patch.object(TestAgent, "_invoke_run")
@patch.object(TestAgent, "_record_metrics")
@patch.object(TestAgent, "_record_worker_events")
@patch.object(TestAgent, "_shutdown")
def test_invoke_run(
self, shutdown_mock, record_events_mock, record_metrics_mock, invoke_run_mock
):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
agent.run()
invoke_run_mock.assert_called_once()
record_metrics_mock.assert_called_once()
record_events_mock.assert_called_once()
shutdown_mock.assert_called_once()
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_metrics_success_no_retries(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
group_result = RunResult({}, {})
agent._record_metrics(group_result)
calls = self._get_record_metrics_test_calls(success_no_retries=1)
put_metric_mock.assert_has_calls(calls, any_order=True)
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_metrics_success_with_retries(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=10)
agent = TestAgent(spec)
agent._remaining_restarts = 2
group_result = RunResult({}, {})
agent._record_metrics(group_result)
calls = self._get_record_metrics_test_calls(success_with_retries=1)
put_metric_mock.assert_has_calls(calls, any_order=True)
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_metrics_failed_with_retries(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=10)
agent = TestAgent(spec)
agent._remaining_restarts = 2
group_result = RunResult(
state=WorkerState.FAILED, return_values={}, failures={0: 0}
)
agent._record_metrics(group_result)
calls = self._get_record_metrics_test_calls(failed_with_retries=1)
put_metric_mock.assert_has_calls(calls, any_order=True)
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_metrics_failed_no_retries(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=10)
agent = TestAgent(spec)
group_result = RunResult(
state=WorkerState.FAILED, return_values={}, failures={0: 0}
)
agent._record_metrics(group_result)
calls = self._get_record_metrics_test_calls(failed_no_retries=1)
put_metric_mock.assert_has_calls(calls, any_order=True)
def _get_record_metrics_test_calls(
self,
success_with_retries=0,
success_no_retries=0,
failed_with_retries=0,
failed_no_retries=0,
):
calls = [
call("workers.test_trainer.run_success_with_retries", success_with_retries),
call("workers.test_trainer.run_success_no_retries", success_no_retries),
call("workers.test_trainer.run_failed_with_retries", failed_with_retries),
call("workers.test_trainer.run_failed_no_retries", failed_no_retries),
]
return calls
def test_rendezvous(self):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._rendezvous(worker_group)
# single agent rdzv
self.assertEqual(1, worker_group.group_world_size)
self.assertEqual(0, worker_group.group_rank)
master_addr, master_port = agent._get_master_addr_port(worker_group.store)
self.assertEqual(_get_fq_hostname(), master_addr)
self.assertTrue(master_port > 0)
rank_set = {w.global_rank for w in worker_group.workers}
for w in worker_group.workers:
self.assertIsNone(w.id)
local_world_size = spec.local_world_size
group_world_size = worker_group.group_world_size
group_rank = worker_group.group_rank
self.assertEqual(local_world_size * group_world_size, w.world_size)
self.assertEqual(
local_world_size * group_rank + w.local_rank, w.global_rank
)
self.assertSetEqual(set(range(w.world_size)), rank_set)
def test_rendezvous_default_master_addr(self):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._rendezvous(worker_group)
master_addr, master_port = agent._get_master_addr_port(worker_group.store)
self.assertEqual(_get_fq_hostname(), master_addr)
self.assertGreater(master_port, 0)
def test_rendezvous_master_addr_with_local_addr(self):
spec_local_addr = "1.2.3.4"
spec = self._get_worker_spec(max_restarts=1, local_addr=spec_local_addr)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._rendezvous(worker_group)
master_addr, master_port = agent._get_master_addr_port(worker_group.store)
self.assertNotEqual(_get_fq_hostname(), master_addr)
self.assertEqual(spec_local_addr, master_addr)
self.assertGreater(master_port, 0)
def test_initialize_workers(self):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._initialize_workers(worker_group)
self.assertEqual(WorkerState.HEALTHY, worker_group.state)
for i in range(spec.local_world_size):
worker = worker_group.workers[i]
self.assertEqual(worker.id, worker.global_rank)
def test_restart_workers(self):
spec = self._get_worker_spec()
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
num_restarts = 3
for _ in range(0, num_restarts):
agent._restart_workers(worker_group)
self.assertEqual(WorkerState.HEALTHY, worker_group.state)
# test_rendezvous and test_initialize_workers
# already validates the correctness of these fields
# simply validate that they are not None
# (e.g. that they get assigned)
self.assertIsNotNone(worker_group.group_rank)
self.assertIsNotNone(worker_group.group_world_size)
for w in worker_group.workers:
self.assertIsNotNone(w.id)
self.assertIsNotNone(w.global_rank)
self.assertIsNotNone(w.world_size)
self.assertEqual(num_restarts, agent.start_workers_call_count)
self.assertEqual(num_restarts, agent.stop_workers_call_count)
@patch.object(
TestAgent,
"_monitor_workers",
side_effect=[
monres(WorkerState.HEALTHY),
monres(WorkerState.HEALTHY),
monres(WorkerState.SUCCEEDED),
],
)
@patch.object(TestAgent, "_record_worker_events")
def test_run_happy_path(self, record_events_mock, mock_monitor_workers):
# worker starts
# is always healthy
# then succeeds
max_restarts = 10
spec = self._get_worker_spec(max_restarts)
agent = TestAgent(spec)
agent.run()
# no failure, no membership changes -> no retries
self.assertEqual(max_restarts, agent._remaining_restarts)
record_events_mock.assert_called_once()
@patch.object(TestAgent, "_initialize_workers", side_effect=RuntimeError())
def test_run_initialization_failure(self, mock_initialize_workers):
spec = self._get_worker_spec()
agent = TestAgent(spec)
worker_group = agent._worker_group
with self.assertRaises(RuntimeError):
agent.run()
self.assertEqual(WorkerState.INIT, worker_group.state)
def test_run_max_retries_exceeded(self):
for restartable_state in [
monres(WorkerState.FAILED),
monres(WorkerState.UNHEALTHY),
]:
with patch.object(
TestAgent, "_monitor_workers", return_value=restartable_state
) as mock_monitor_workers:
spec = self._get_worker_spec(max_restarts=3, monitor_interval=0.1)
agent = TestAgent(spec)
worker_group = agent._worker_group
agent.run()
self.assertEqual(WorkerState.FAILED, worker_group.state)
self.assertEqual(0, agent._remaining_restarts)
# one monitor call for each retry + one to monitor the last retry
self.assertEqual(spec.max_restarts + 1, mock_monitor_workers.call_count)
@patch.object(
TestAgent,
"_monitor_workers",
side_effect=[
monres(WorkerState.HEALTHY),
monres(WorkerState.HEALTHY),
monres(WorkerState.HEALTHY),
monres(WorkerState.SUCCEEDED),
],
)
@patch.object(RendezvousHandler, "num_nodes_waiting", side_effect=[1, 1, 0])
@patch.object(TestAgent, "_record_worker_events")
def test_run_membership_change(
self, record_events_mock, mock_num_nodes_waiting, mock_monitor_workers
):
spec = self._get_worker_spec(max_restarts=1, monitor_interval=0.1)
agent = TestAgent(spec)
worker_group = agent._worker_group
agent.run()
self.assertEqual(WorkerState.SUCCEEDED, worker_group.state)
record_events_mock.assert_called_once()
@patch.object(
TestAgent, "_monitor_workers", return_value=monres(WorkerState.UNKNOWN)
)
def test_run_unknown_state(self, mock_monitor_workers):
# when the state is unknown we exit immediately; no retries
spec = self._get_worker_spec(max_restarts=100, monitor_interval=0.1)
agent = TestAgent(spec)
worker_group = agent._worker_group
with self.assertRaises(Exception):
agent.run()
self.assertEqual(WorkerState.UNKNOWN, worker_group.state)
self.assertEqual(1, mock_monitor_workers.call_count)
self.assertEqual(spec.max_restarts, agent._remaining_restarts)
def test_get_ranks(self):
role_infos = [
_RoleInstanceInfo("parameter_server", 0, 4),
_RoleInstanceInfo("trainer", 1, 1),
_RoleInstanceInfo("trainer", 2, 2),
_RoleInstanceInfo("trainer", 3, 3),
_RoleInstanceInfo("parameter_server", 4, 5),
]
spec = self._get_worker_spec(
max_restarts=3, monitor_interval=0.1, role="not_used", local_world_size=8
)
agent = TestAgent(spec)
total_sum, ranks = agent._get_ranks(role_infos, 0, 0, len(role_infos))
self.assertEqual(15, total_sum)
self.assertEqual([0, 1, 2, 3], list(ranks))
def test_assign_worker_ranks(self):
role_infos = [
_RoleInstanceInfo("parameter_server", 0, 4),
_RoleInstanceInfo("trainer", 1, 1),
_RoleInstanceInfo("trainer", 2, 2),
_RoleInstanceInfo("trainer", 3, 3),
_RoleInstanceInfo("parameter_server", 4, 5),
]
num_agents = len(role_infos)
with patch.object(TestAgent, "_share_and_gather", return_value=role_infos):
self.verify_worker_ranks(
role_infos[0], num_agents, [0, 1, 2, 3], [0, 1, 2, 3]
)
self.verify_worker_ranks(role_infos[1], num_agents, [4], [0])
self.verify_worker_ranks(role_infos[2], num_agents, [5, 6], [1, 2])
self.verify_worker_ranks(role_infos[3], num_agents, [7, 8, 9], [3, 4, 5])
def verify_worker_ranks(
self, agent_config, total_agents, expected_global_ranks, expected_role_ranks
):
role, agent_rank, local_world_size = (
agent_config.role,
agent_config.rank,
agent_config.local_world_size,
)
spec = self._get_worker_spec(
max_restarts=3,
monitor_interval=0.1,
role=role,
local_world_size=local_world_size,
)
agent = TestAgent(spec)
workers = agent._assign_worker_ranks(None, agent_rank, total_agents, spec)
self.assertEqual(
expected_global_ranks, [worker.global_rank for worker in workers]
)
self.assertEqual(expected_role_ranks, [worker.role_rank for worker in workers])
@patch("torch.distributed.elastic.utils.store.synchronize")
def test_share_and_gather(self, sync_mock):
# when the state is unknown we exit immediately; no retries
spec = self._get_worker_spec(max_restarts=100, monitor_interval=0.1)
agent = TestAgent(spec)
expected_agent_infos = [
_RoleInstanceInfo("trainer", 0, 10),
_RoleInstanceInfo("trainer", 1, 10),
_RoleInstanceInfo("validator", 2, 10),
]
sync_mock.return_value = [obj.serialize() for obj in expected_agent_infos]
result = agent._share_and_gather(MagicMock(), 1, 3, spec)
sync_mock.assert_called_once()
for expected_role_info, actual_role_info in zip(expected_agent_infos, result):
self.assertEqual(expected_role_info.role, actual_role_info.role)
self.assertEqual(expected_role_info.rank, actual_role_info.rank)
self.assertEqual(
expected_role_info.local_world_size, actual_role_info.local_world_size
)
def test_get_event(self):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
event = agent.get_event_succeeded()
self.assertEqual("AGENT", event.source)
self.assertEqual("static", event.metadata["rdzv_backend"])
self.assertEqual("SUCCEEDED", event.metadata["state"])
self.assertEqual(spec.role, event.metadata["role"])
def test_get_worker_status_event(self):
spec = self._get_worker_spec(max_restarts=4)
agent = TestAgent(spec)
agent._remaining_restarts = spec.max_restarts - 2
actual_event = agent._construct_event(
state="SUCCEEDED",
source="WORKER",
worker=agent._worker_group.workers[0],
)
self.assertEqual("WORKER", actual_event.source)
self.assertEqual("static", actual_event.metadata["rdzv_backend"])
self.assertEqual("SUCCEEDED", actual_event.metadata["state"])
self.assertEqual(spec.role, actual_event.metadata["role"])
self.assertEqual(2, actual_event.metadata["agent_restarts"])
@patch("torch.distributed.elastic.agent.server.api.put_metric")
@patch.object(TestAgent, "_invoke_run")
def test_agent_process_signal_exception(self, invoke_run, _):
spec = self._get_worker_spec(max_restarts=0)
agent = TestAgent(spec)
invoke_run.side_effect = SignalException(
"signal exception", sigval=signal.SIGTERM
)
with patch.object(agent, "_shutdown") as shutdown_mock:
with self.assertRaises(SignalException):
agent.run()
args, _ = shutdown_mock.call_args
self.assertEqual(signal.SIGTERM, args[0])
if __name__ == "__main__":
run_tests()
|
def monres(state: WorkerState):
if state == WorkerState.SUCCEEDED:
return RunResult(state=state, return_values={0: 0}, failures={})
elif state in {WorkerState.UNHEALTHY, WorkerState.FAILED}:
pf = ProcessFailure(local_rank=0, pid=999, exitcode=1, error_file="<none>")
return RunResult(state=state, return_values={}, failures={0: pf})
else:
return RunResult(state=state)
class SimpleElasticAgentTest(unittest.TestCase):
def _get_worker_spec(
self,
max_restarts=1,
monitor_interval=0.1,
role="test_trainer",
local_world_size=8,
local_addr=None,
):
run_id = str(uuid.uuid4().int)
port = get_free_port()
if local_addr is None:
endpoint = f"127.0.0.1:{port}"
else:
endpoint = f"{local_addr}:{port}"
rdzv_params = RendezvousParameters(
backend="static",
endpoint=endpoint,
run_id=run_id,
min_nodes=1,
max_nodes=1,
rank=0,
)
rdzv_handler = rdzv_registry.get_rendezvous_handler(rdzv_params)
spec = WorkerSpec(
role=role,
local_world_size=local_world_size,
fn=do_nothing,
args=(),
rdzv_handler=rdzv_handler,
max_restarts=max_restarts,
monitor_interval=monitor_interval,
local_addr=local_addr,
)
return spec
def test_agent_constructor(self):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
self.assertEqual(WorkerState.INIT, worker_group.state)
self.assertEqual(spec.max_restarts, agent._remaining_restarts)
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_flakiness_metric(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
agent._record_flakiness_metric()
put_metric_mock.assert_called_with("workers.test_trainer.flakiness", 0)
agent._worker_group.spec.max_restarts = 10
agent._remaining_restarts = 3
agent._record_flakiness_metric()
put_metric_mock.assert_called_with("workers.test_trainer.flakiness", 63)
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_flakiness_metric_zero_restarts(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=1)
spec.max_restarts = 0
agent = TestAgent(spec)
agent._record_flakiness_metric()
put_metric_mock.assert_called_with("workers.test_trainer.flakiness", 0)
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_flakiness_metric_user_exception(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
agent._record_flakiness_metric(True)
put_metric_mock.assert_called_with("workers.test_trainer.flakiness", 100)
@patch.object(TestAgent, "_invoke_run")
@patch.object(TestAgent, "_record_metrics")
@patch.object(TestAgent, "_record_worker_events")
@patch.object(TestAgent, "_shutdown")
def test_invoke_run(
self, shutdown_mock, record_events_mock, record_metrics_mock, invoke_run_mock
):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
agent.run()
invoke_run_mock.assert_called_once()
record_metrics_mock.assert_called_once()
record_events_mock.assert_called_once()
shutdown_mock.assert_called_once()
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_metrics_success_no_retries(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
group_result = RunResult({}, {})
agent._record_metrics(group_result)
calls = self._get_record_metrics_test_calls(success_no_retries=1)
put_metric_mock.assert_has_calls(calls, any_order=True)
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_metrics_success_with_retries(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=10)
agent = TestAgent(spec)
agent._remaining_restarts = 2
group_result = RunResult({}, {})
agent._record_metrics(group_result)
calls = self._get_record_metrics_test_calls(success_with_retries=1)
put_metric_mock.assert_has_calls(calls, any_order=True)
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_metrics_failed_with_retries(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=10)
agent = TestAgent(spec)
agent._remaining_restarts = 2
group_result = RunResult(
state=WorkerState.FAILED, return_values={}, failures={0: 0}
)
agent._record_metrics(group_result)
calls = self._get_record_metrics_test_calls(failed_with_retries=1)
put_metric_mock.assert_has_calls(calls, any_order=True)
@patch("torch.distributed.elastic.agent.server.api.put_metric")
def test_record_metrics_failed_no_retries(self, put_metric_mock):
spec = self._get_worker_spec(max_restarts=10)
agent = TestAgent(spec)
group_result = RunResult(
state=WorkerState.FAILED, return_values={}, failures={0: 0}
)
agent._record_metrics(group_result)
calls = self._get_record_metrics_test_calls(failed_no_retries=1)
put_metric_mock.assert_has_calls(calls, any_order=True)
def _get_record_metrics_test_calls(
self,
success_with_retries=0,
success_no_retries=0,
failed_with_retries=0,
failed_no_retries=0,
):
calls = [
call("workers.test_trainer.run_success_with_retries", success_with_retries),
call("workers.test_trainer.run_success_no_retries", success_no_retries),
call("workers.test_trainer.run_failed_with_retries", failed_with_retries),
call("workers.test_trainer.run_failed_no_retries", failed_no_retries),
]
return calls
def test_rendezvous(self):
hostname = _get_fq_hostname()
spec = self._get_worker_spec(max_restarts=1, local_addr=hostname)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._rendezvous(worker_group)
# single agent rdzv
self.assertEqual(1, worker_group.group_world_size)
self.assertEqual(0, worker_group.group_rank)
self.assertEqual(hostname, worker_group.master_addr)
self.assertTrue(worker_group.master_port > 0)
rank_set = {w.global_rank for w in worker_group.workers}
for w in worker_group.workers:
self.assertIsNone(w.id)
local_world_size = spec.local_world_size
group_world_size = worker_group.group_world_size
group_rank = worker_group.group_rank
self.assertEqual(local_world_size * group_world_size, w.world_size)
self.assertEqual(
local_world_size * group_rank + w.local_rank, w.global_rank
)
self.assertSetEqual(set(range(w.world_size)), rank_set)
def test_rendezvous_default_master_addr(self):
hostname = _get_fq_hostname()
spec = self._get_worker_spec(max_restarts=1, local_addr=hostname)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._rendezvous(worker_group)
self.assertEqual(_get_fq_hostname(), worker_group.master_addr)
self.assertGreater(worker_group.master_port, 0)
def test_rendezvous_master_addr_with_local_addr(self):
spec_local_addr = "127.0.0.1"
spec = self._get_worker_spec(max_restarts=1, local_addr=spec_local_addr)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._rendezvous(worker_group)
self.assertNotEqual(_get_fq_hostname(), worker_group.master_addr)
self.assertEqual(spec_local_addr, worker_group.master_addr)
self.assertGreater(worker_group.master_port, 0)
def test_initialize_workers(self):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
agent._initialize_workers(worker_group)
self.assertEqual(WorkerState.HEALTHY, worker_group.state)
for i in range(spec.local_world_size):
worker = worker_group.workers[i]
self.assertEqual(worker.id, worker.global_rank)
def test_restart_workers(self):
spec = self._get_worker_spec()
agent = TestAgent(spec)
worker_group = agent.get_worker_group()
num_restarts = 3
for _ in range(0, num_restarts):
agent._restart_workers(worker_group)
self.assertEqual(WorkerState.HEALTHY, worker_group.state)
# test_rendezvous and test_initialize_workers
# already validates the correctness of these fields
# simply validate that they are not None
# (e.g. that they get assigned)
self.assertIsNotNone(worker_group.group_rank)
self.assertIsNotNone(worker_group.group_world_size)
for w in worker_group.workers:
self.assertIsNotNone(w.id)
self.assertIsNotNone(w.global_rank)
self.assertIsNotNone(w.world_size)
self.assertEqual(num_restarts, agent.start_workers_call_count)
self.assertEqual(num_restarts, agent.stop_workers_call_count)
@patch.object(
TestAgent,
"_monitor_workers",
side_effect=[
monres(WorkerState.HEALTHY),
monres(WorkerState.HEALTHY),
monres(WorkerState.SUCCEEDED),
],
)
@patch.object(TestAgent, "_record_worker_events")
def test_run_happy_path(self, record_events_mock, mock_monitor_workers):
# worker starts
# is always healthy
# then succeeds
max_restarts = 10
spec = self._get_worker_spec(max_restarts)
agent = TestAgent(spec)
agent.run()
# no failure, no membership changes -> no retries
self.assertEqual(max_restarts, agent._remaining_restarts)
record_events_mock.assert_called_once()
@patch.object(TestAgent, "_initialize_workers", side_effect=RuntimeError())
def test_run_initialization_failure(self, mock_initialize_workers):
spec = self._get_worker_spec()
agent = TestAgent(spec)
worker_group = agent._worker_group
with self.assertRaises(RuntimeError):
agent.run()
self.assertEqual(WorkerState.INIT, worker_group.state)
def test_run_max_retries_exceeded(self):
for restartable_state in [
monres(WorkerState.FAILED),
monres(WorkerState.UNHEALTHY),
]:
with patch.object(
TestAgent, "_monitor_workers", return_value=restartable_state
) as mock_monitor_workers:
spec = self._get_worker_spec(max_restarts=3, monitor_interval=0.1)
agent = TestAgent(spec)
worker_group = agent._worker_group
agent.run()
self.assertEqual(WorkerState.FAILED, worker_group.state)
self.assertEqual(0, agent._remaining_restarts)
# one monitor call for each retry + one to monitor the last retry
self.assertEqual(spec.max_restarts + 1, mock_monitor_workers.call_count)
@patch.object(
TestAgent,
"_monitor_workers",
side_effect=[
monres(WorkerState.HEALTHY),
monres(WorkerState.HEALTHY),
monres(WorkerState.HEALTHY),
monres(WorkerState.SUCCEEDED),
],
)
@patch.object(RendezvousHandler, "num_nodes_waiting", side_effect=[1, 1, 0])
@patch.object(TestAgent, "_record_worker_events")
def test_run_membership_change(
self, record_events_mock, mock_num_nodes_waiting, mock_monitor_workers
):
spec = self._get_worker_spec(max_restarts=1, monitor_interval=0.1)
agent = TestAgent(spec)
worker_group = agent._worker_group
agent.run()
self.assertEqual(WorkerState.SUCCEEDED, worker_group.state)
record_events_mock.assert_called_once()
@patch.object(
TestAgent, "_monitor_workers", return_value=monres(WorkerState.UNKNOWN)
)
def test_run_unknown_state(self, mock_monitor_workers):
# when the state is unknown we exit immediately; no retries
spec = self._get_worker_spec(max_restarts=100, monitor_interval=0.1)
agent = TestAgent(spec)
worker_group = agent._worker_group
with self.assertRaises(Exception):
agent.run()
self.assertEqual(WorkerState.UNKNOWN, worker_group.state)
self.assertEqual(1, mock_monitor_workers.call_count)
self.assertEqual(spec.max_restarts, agent._remaining_restarts)
def test_assign_worker_ranks(self):
role_infos = [
_RoleInstanceInfo("parameter_server", 0, 4),
_RoleInstanceInfo("trainer", 1, 1),
_RoleInstanceInfo("trainer", 2, 2),
_RoleInstanceInfo("trainer", 3, 3),
_RoleInstanceInfo("parameter_server", 4, 5),
]
store = dist.HashStore()
def f(info) -> List[Worker]:
i, role_info = info
spec = self._get_worker_spec(
max_restarts=3,
monitor_interval=0.1,
role=role_info.role,
local_world_size=role_info.local_world_size,
)
agent = TestAgent(spec)
workers = agent._assign_worker_ranks(
store, role_info.rank, len(role_infos), spec
)
return [
(
w.local_rank,
w.role_rank,
w.global_rank,
w.world_size,
w.role_world_size,
)
for w in workers
]
with ThreadPool(len(role_infos)) as pool:
out = pool.map(f, enumerate(role_infos))
self.assertListEqual(
out,
[
[
(0, 0, 0, 15, 9),
(1, 1, 1, 15, 9),
(2, 2, 2, 15, 9),
(3, 3, 3, 15, 9),
],
[
(0, 0, 4, 15, 6),
],
[
(0, 1, 5, 15, 6),
(1, 2, 6, 15, 6),
],
[
(0, 3, 7, 15, 6),
(1, 4, 8, 15, 6),
(2, 5, 9, 15, 6),
],
[
(0, 4, 10, 15, 9),
(1, 5, 11, 15, 9),
(2, 6, 12, 15, 9),
(3, 7, 13, 15, 9),
(4, 8, 14, 15, 9),
],
],
)
def test_get_event(self):
spec = self._get_worker_spec(max_restarts=1)
agent = TestAgent(spec)
event = agent.get_event_succeeded()
self.assertEqual("AGENT", event.source)
self.assertEqual("static", event.metadata["rdzv_backend"])
self.assertEqual("SUCCEEDED", event.metadata["state"])
self.assertEqual(spec.role, event.metadata["role"])
def test_get_worker_status_event(self):
spec = self._get_worker_spec(max_restarts=4)
agent = TestAgent(spec)
agent._remaining_restarts = spec.max_restarts - 2
actual_event = agent._construct_event(
state="SUCCEEDED",
source="WORKER",
worker=agent._worker_group.workers[0],
)
self.assertEqual("WORKER", actual_event.source)
self.assertEqual("static", actual_event.metadata["rdzv_backend"])
self.assertEqual("SUCCEEDED", actual_event.metadata["state"])
self.assertEqual(spec.role, actual_event.metadata["role"])
self.assertEqual(2, actual_event.metadata["agent_restarts"])
@patch("torch.distributed.elastic.agent.server.api.put_metric")
@patch.object(TestAgent, "_invoke_run")
def test_agent_process_signal_exception(self, invoke_run, _):
spec = self._get_worker_spec(max_restarts=0)
agent = TestAgent(spec)
invoke_run.side_effect = SignalException(
"signal exception", sigval=signal.SIGTERM
)
with patch.object(agent, "_shutdown") as shutdown_mock:
with self.assertRaises(SignalException):
agent.run()
args, _ = shutdown_mock.call_args
self.assertEqual(signal.SIGTERM, args[0])
@patch("torch.distributed.elastic.agent.server.api.put_metric")
@patch.object(TestAgent, "_invoke_run")
def test_agent_process_handler_graceful_exception(self, invoke_run, _):
spec = self._get_worker_spec(max_restarts=0)
agent = TestAgent(spec)
invoke_run.side_effect = RendezvousGracefulExitError()
with patch.object(agent, "_shutdown"):
agent.run()
if __name__ == "__main__":
run_tests()
|
import signal
import unittest
import uuid
from typing import Any, Dict
from unittest.mock import call, patch, MagicMock
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
RunResult,
SimpleElasticAgent,
WorkerGroup,
WorkerSpec,
WorkerState,
_get_fq_hostname,
_RoleInstanceInfo,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
|
import signal
import unittest
import uuid
from multiprocessing.pool import ThreadPool
from typing import Any, Dict, List
from unittest.mock import call, patch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
from torch.distributed.elastic.agent.server.api import (
_get_fq_hostname,
_RoleInstanceInfo,
RunResult,
SimpleElasticAgent,
Worker,
WorkerGroup,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.multiprocessing import SignalException
from torch.distributed.elastic.multiprocessing.errors import ProcessFailure
from torch.distributed.elastic.rendezvous import RendezvousHandler, RendezvousParameters
from torch.distributed.elastic.rendezvous.api import RendezvousGracefulExitError
from torch.distributed.elastic.utils.distributed import get_free_port
from torch.testing._internal.common_utils import run_tests
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/agent/server/test/local_elastic_agent_test.py
|
_check_env_function
|
def _check_env_function():
# just check these env vars exist, os.environ[...] will naturally throw
# if the variable does not exist
env_vars = [
"RANK",
"LOCAL_RANK",
"ROLE_RANK",
"ROLE_NAME",
"GROUP_RANK",
"LOCAL_WORLD_SIZE",
"ROLE_WORLD_SIZE",
"WORLD_SIZE",
"GROUP_WORLD_SIZE",
"MASTER_ADDR",
"MASTER_PORT",
"TORCHELASTIC_RESTART_COUNT",
"TORCHELASTIC_MAX_RESTARTS",
"TORCHELASTIC_RUN_ID",
"TORCHELASTIC_USE_AGENT_STORE",
"NCCL_ASYNC_ERROR_HANDLING",
]
for var in env_vars:
_ = os.environ[var]
|
def _check_env_function():
# just check these env vars exist, os.environ[...] will naturally throw
# if the variable does not exist
env_vars = [
"RANK",
"LOCAL_RANK",
"ROLE_RANK",
"ROLE_NAME",
"GROUP_RANK",
"LOCAL_WORLD_SIZE",
"ROLE_WORLD_SIZE",
"WORLD_SIZE",
"GROUP_WORLD_SIZE",
"MASTER_ADDR",
"MASTER_PORT",
"TORCHELASTIC_RESTART_COUNT",
"TORCHELASTIC_MAX_RESTARTS",
"TORCHELASTIC_RUN_ID",
"TORCHELASTIC_USE_AGENT_STORE",
"TORCH_NCCL_ASYNC_ERROR_HANDLING",
]
for var in env_vars:
_ = os.environ[var]
|
import json
import multiprocessing as mp
import os
import shutil
import signal
import socket
import tempfile
import time
import unittest
import uuid
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Tuple
from unittest import mock
from unittest.mock import Mock, patch
import torch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
import torch.distributed.rpc as rpc
from torch.distributed.elastic.agent.server.api import (
RunResult,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.agent.server.local_elastic_agent import (
LocalElasticAgent,
TORCHELASTIC_TIMER_FILE,
)
from torch.distributed.elastic.multiprocessing import Std
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError, record
from torch.distributed.elastic.rendezvous import RendezvousParameters
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.rpc.backend_registry import BackendType
from torch.testing._internal.common_utils import (
sandcastle_skip_if,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
)
|
import json
import multiprocessing as mp
import os
import shutil
import signal
import socket
import tempfile
import time
import unittest
import uuid
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Tuple
from unittest import mock
from unittest.mock import Mock, patch
import torch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
import torch.distributed.rpc as rpc
from torch.distributed.elastic.agent.server.api import (
RunResult,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.agent.server.local_elastic_agent import (
LocalElasticAgent,
TORCHELASTIC_HEALTH_CHECK_PORT,
TORCHELASTIC_TIMER_FILE,
)
from torch.distributed.elastic.multiprocessing import DefaultLogsSpecs, Std
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError, record
from torch.distributed.elastic.rendezvous import RendezvousParameters
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.rpc.backend_registry import BackendType
from torch.testing._internal.common_utils import (
skip_but_pass_in_sandcastle_if,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
)
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/agent/server/test/local_elastic_agent_test.py
|
test_no_exit_barrier_on_failure
|
def test_no_exit_barrier_on_failure(self):
self.run_test_with_backend(
backend="c10d", test_to_run=self.no_exit_barrier_on_failure
)
|
import json
import multiprocessing as mp
import os
import shutil
import signal
import socket
import tempfile
import time
import unittest
import uuid
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Tuple
from unittest import mock
from unittest.mock import Mock, patch
import torch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
import torch.distributed.rpc as rpc
from torch.distributed.elastic.agent.server.api import (
RunResult,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.agent.server.local_elastic_agent import (
LocalElasticAgent,
TORCHELASTIC_HEALTH_CHECK_PORT,
TORCHELASTIC_TIMER_FILE,
)
from torch.distributed.elastic.multiprocessing import DefaultLogsSpecs, Std
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError, record
from torch.distributed.elastic.rendezvous import RendezvousParameters
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.rpc.backend_registry import BackendType
from torch.testing._internal.common_utils import (
skip_but_pass_in_sandcastle_if,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
)
class LocalElasticAgentTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/elastic/agent/server/test/local_elastic_agent_test.py
|
run_check_nccl_async_error_handling_env
|
def run_check_nccl_async_error_handling_env(self):
# make sure NCCL_ASYNC_ERROR_HANDLING set in os.environ is honored
with patch.dict(os.environ, {"NCCL_ASYNC_ERROR_HANDLING": "0"}):
res = self.run_agent(
Conf(
entrypoint=_check_env_value,
local_world_size=1,
args=("NCCL_ASYNC_ERROR_HANDLING", "0"),
)
)
self.assertFalse(res.is_failed())
|
def run_check_nccl_async_error_handling_env(self):
# make sure TORCH_NCCL_ASYNC_ERROR_HANDLING set in os.environ is honored
with patch.dict(os.environ, {"TORCH_NCCL_ASYNC_ERROR_HANDLING": "0"}):
res = self.run_agent(
Conf(
entrypoint=_check_env_value,
local_world_size=1,
args=("TORCH_NCCL_ASYNC_ERROR_HANDLING", "0"),
)
)
self.assertFalse(res.is_failed())
|
import json
import multiprocessing as mp
import os
import shutil
import signal
import socket
import tempfile
import time
import unittest
import uuid
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Tuple
from unittest import mock
from unittest.mock import Mock, patch
import torch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
import torch.distributed.rpc as rpc
from torch.distributed.elastic.agent.server.api import (
RunResult,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.agent.server.local_elastic_agent import (
LocalElasticAgent,
TORCHELASTIC_TIMER_FILE,
)
from torch.distributed.elastic.multiprocessing import Std
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError, record
from torch.distributed.elastic.rendezvous import RendezvousParameters
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.rpc.backend_registry import BackendType
from torch.testing._internal.common_utils import (
sandcastle_skip_if,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
)
class LocalElasticAgentTest(unittest.TestCase):
|
import json
import multiprocessing as mp
import os
import shutil
import signal
import socket
import tempfile
import time
import unittest
import uuid
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Tuple
from unittest import mock
from unittest.mock import Mock, patch
import torch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
import torch.distributed.rpc as rpc
from torch.distributed.elastic.agent.server.api import (
RunResult,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.agent.server.local_elastic_agent import (
LocalElasticAgent,
TORCHELASTIC_HEALTH_CHECK_PORT,
TORCHELASTIC_TIMER_FILE,
)
from torch.distributed.elastic.multiprocessing import DefaultLogsSpecs, Std
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError, record
from torch.distributed.elastic.rendezvous import RendezvousParameters
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.rpc.backend_registry import BackendType
from torch.testing._internal.common_utils import (
skip_but_pass_in_sandcastle_if,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
)
class LocalElasticAgentTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/agent/server/test/local_elastic_agent_test.py
|
run_check_nccl_async_error_handling_env_default
|
def run_check_nccl_async_error_handling_env_default(self):
# if not present in env var it should default to 1
res = self.run_agent(
Conf(
entrypoint=_check_env_value,
local_world_size=1,
args=("NCCL_ASYNC_ERROR_HANDLING", "1"),
)
)
self.assertFalse(res.is_failed())
|
def run_check_nccl_async_error_handling_env_default(self):
# if not present in env var it should default to 1
res = self.run_agent(
Conf(
entrypoint=_check_env_value,
local_world_size=1,
args=("TORCH_NCCL_ASYNC_ERROR_HANDLING", "1"),
)
)
self.assertFalse(res.is_failed())
|
import json
import multiprocessing as mp
import os
import shutil
import signal
import socket
import tempfile
import time
import unittest
import uuid
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Tuple
from unittest import mock
from unittest.mock import Mock, patch
import torch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
import torch.distributed.rpc as rpc
from torch.distributed.elastic.agent.server.api import (
RunResult,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.agent.server.local_elastic_agent import (
LocalElasticAgent,
TORCHELASTIC_TIMER_FILE,
)
from torch.distributed.elastic.multiprocessing import Std
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError, record
from torch.distributed.elastic.rendezvous import RendezvousParameters
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.rpc.backend_registry import BackendType
from torch.testing._internal.common_utils import (
sandcastle_skip_if,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
)
class LocalElasticAgentTest(unittest.TestCase):
|
import json
import multiprocessing as mp
import os
import shutil
import signal
import socket
import tempfile
import time
import unittest
import uuid
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Tuple
from unittest import mock
from unittest.mock import Mock, patch
import torch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
import torch.distributed.rpc as rpc
from torch.distributed.elastic.agent.server.api import (
RunResult,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.agent.server.local_elastic_agent import (
LocalElasticAgent,
TORCHELASTIC_HEALTH_CHECK_PORT,
TORCHELASTIC_TIMER_FILE,
)
from torch.distributed.elastic.multiprocessing import DefaultLogsSpecs, Std
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError, record
from torch.distributed.elastic.rendezvous import RendezvousParameters
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.rpc.backend_registry import BackendType
from torch.testing._internal.common_utils import (
skip_but_pass_in_sandcastle_if,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
)
class LocalElasticAgentTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/agent/server/test/local_elastic_agent_test.py
|
run_agent_local_watchdog_setup_enabled
|
def run_agent_local_watchdog_setup_enabled(self):
# Set the env for watchdog
watchdog_env_name = TORCHELASTIC_TIMER_FILE
watchdog_file_path = "/tmp/watchdog_timer_" + str(uuid.uuid4())
os.environ[watchdog_env_name] = watchdog_file_path
# Run the agent
node_conf = Conf(entrypoint=_check_local_watchdog_setup, local_world_size=1, args=(TORCHELASTIC_TIMER_FILE, True))
spec = self.get_worker_spec(node_conf, max_restarts=2)
agent = self.get_agent(spec)
res = agent.run()
self.assertFalse(res.is_failed())
|
def run_agent_local_watchdog_setup_enabled(self):
# Set the env for watchdog
watchdog_env_name = TORCHELASTIC_TIMER_FILE
watchdog_file_path = "/tmp/watchdog_timer_" + str(uuid.uuid4())
os.environ[watchdog_env_name] = watchdog_file_path
# Run the agent
node_conf = Conf(
entrypoint=_check_local_watchdog_setup,
local_world_size=1,
args=(TORCHELASTIC_TIMER_FILE, True),
)
spec = self.get_worker_spec(node_conf, max_restarts=2)
agent = self.get_agent(spec, node_config=node_conf)
res = agent.run()
self.assertFalse(res.is_failed())
|
import json
import multiprocessing as mp
import os
import shutil
import signal
import socket
import tempfile
import time
import unittest
import uuid
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Tuple
from unittest import mock
from unittest.mock import Mock, patch
import torch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
import torch.distributed.rpc as rpc
from torch.distributed.elastic.agent.server.api import (
RunResult,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.agent.server.local_elastic_agent import (
LocalElasticAgent,
TORCHELASTIC_TIMER_FILE,
)
from torch.distributed.elastic.multiprocessing import Std
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError, record
from torch.distributed.elastic.rendezvous import RendezvousParameters
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.rpc.backend_registry import BackendType
from torch.testing._internal.common_utils import (
sandcastle_skip_if,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
)
class LocalElasticAgentTest(unittest.TestCase):
|
import json
import multiprocessing as mp
import os
import shutil
import signal
import socket
import tempfile
import time
import unittest
import uuid
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Tuple
from unittest import mock
from unittest.mock import Mock, patch
import torch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
import torch.distributed.rpc as rpc
from torch.distributed.elastic.agent.server.api import (
RunResult,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.agent.server.local_elastic_agent import (
LocalElasticAgent,
TORCHELASTIC_HEALTH_CHECK_PORT,
TORCHELASTIC_TIMER_FILE,
)
from torch.distributed.elastic.multiprocessing import DefaultLogsSpecs, Std
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError, record
from torch.distributed.elastic.rendezvous import RendezvousParameters
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.rpc.backend_registry import BackendType
from torch.testing._internal.common_utils import (
skip_but_pass_in_sandcastle_if,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
)
class LocalElasticAgentTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/agent/server/test/local_elastic_agent_test.py
|
run_agent_healthcheck_setup_enabled
|
def run_agent_healthcheck_setup_enabled(self):
# Set the env for healthcheck
healthcheck_port_env_name = TORCHELASTIC_HEALTH_CHECK_PORT
os.environ[healthcheck_port_env_name] = "12345"
# Run the agent
node_conf = Conf(
entrypoint=_check_local_watchdog_setup,
local_world_size=1,
args=(TORCHELASTIC_HEALTH_CHECK_PORT, True),
)
spec = self.get_worker_spec(node_conf, max_restarts=2)
agent = self.get_agent(spec, node_config=node_conf)
res = agent.run()
self.assertFalse(res.is_failed())
|
import json
import multiprocessing as mp
import os
import shutil
import signal
import socket
import tempfile
import time
import unittest
import uuid
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Tuple
from unittest import mock
from unittest.mock import Mock, patch
import torch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
import torch.distributed.rpc as rpc
from torch.distributed.elastic.agent.server.api import (
RunResult,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.agent.server.local_elastic_agent import (
LocalElasticAgent,
TORCHELASTIC_HEALTH_CHECK_PORT,
TORCHELASTIC_TIMER_FILE,
)
from torch.distributed.elastic.multiprocessing import DefaultLogsSpecs, Std
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError, record
from torch.distributed.elastic.rendezvous import RendezvousParameters
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.rpc.backend_registry import BackendType
from torch.testing._internal.common_utils import (
skip_but_pass_in_sandcastle_if,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
)
class LocalElasticAgentTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/elastic/agent/server/test/local_elastic_agent_test.py
|
test_rank_restart_after_failure
|
def test_rank_restart_after_failure(self):
self.run_test_with_backend(backend="c10d", test_to_run=self.fail_rank_one_once)
|
import json
import multiprocessing as mp
import os
import shutil
import signal
import socket
import tempfile
import time
import unittest
import uuid
from dataclasses import dataclass
from typing import Callable, Dict, List, Optional, Tuple
from unittest import mock
from unittest.mock import Mock, patch
import torch
import torch.distributed as dist
import torch.distributed.elastic.rendezvous.registry as rdzv_registry
import torch.distributed.rpc as rpc
from torch.distributed.elastic.agent.server.api import (
RunResult,
WorkerSpec,
WorkerState,
)
from torch.distributed.elastic.agent.server.local_elastic_agent import (
LocalElasticAgent,
TORCHELASTIC_HEALTH_CHECK_PORT,
TORCHELASTIC_TIMER_FILE,
)
from torch.distributed.elastic.multiprocessing import DefaultLogsSpecs, Std
from torch.distributed.elastic.multiprocessing.errors import ChildFailedError, record
from torch.distributed.elastic.rendezvous import RendezvousParameters
from torch.distributed.elastic.rendezvous.etcd_server import EtcdServer
from torch.distributed.rpc.backend_registry import BackendType
from torch.testing._internal.common_utils import (
skip_but_pass_in_sandcastle_if,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
)
class LocalElasticAgentTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/elastic/metrics/api_test.py
|
func
|
def func(self):
raise NotImplementedError()
|
def func(self):
raise NotImplementedError
|
import abc
import unittest.mock as mock
from torch.distributed.elastic.metrics.api import (
MetricData,
MetricHandler,
MetricStream,
_get_metric_name,
prof,
)
from torch.testing._internal.common_utils import run_tests, TestCase
class Parent(abc.ABC):
|
import abc
import unittest.mock as mock
from torch.distributed.elastic.metrics.api import (
_get_metric_name,
MetricData,
MetricHandler,
MetricStream,
prof,
)
from torch.testing._internal.common_utils import run_tests, TestCase
class Parent(abc.ABC):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/metrics/api_test.py
|
func
|
def func(self):
raise NotImplementedError()
|
def func(self):
raise NotImplementedError
|
import abc
import unittest.mock as mock
from torch.distributed.elastic.metrics.api import (
MetricData,
MetricHandler,
MetricStream,
_get_metric_name,
prof,
)
from torch.testing._internal.common_utils import run_tests, TestCase
class Parent(abc.ABC):
|
import abc
import unittest.mock as mock
from torch.distributed.elastic.metrics.api import (
_get_metric_name,
MetricData,
MetricHandler,
MetricStream,
prof,
)
from torch.testing._internal.common_utils import run_tests, TestCase
class Parent(abc.ABC):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_invalid_log_dir
|
def test_invalid_log_dir(self):
with tempfile.NamedTemporaryFile(dir=self.test_dir) as not_a_dir:
cases = {
"does_not_exist": FileNotFoundError,
not_a_dir.name: NotADirectoryError,
# test_dir is not empty since we touched not_a_dir file
self.test_dir: RuntimeError,
}
for (log_dir, expected_error) in cases.items():
with self.subTest(log_dir=log_dir, expected_error=expected_error):
with self.assertRaises(expected_error):
start_processes(
name="echo",
entrypoint=echo1,
args={0: ("hello",)},
envs={0: {"RANK": "0"}},
log_dir=log_dir,
)
|
def test_invalid_log_dir(self):
with tempfile.NamedTemporaryFile(dir=self.test_dir) as not_a_dir:
cases = {
not_a_dir.name: NotADirectoryError,
}
for log_dir, expected_error in cases.items():
with self.subTest(log_dir=log_dir, expected_error=expected_error):
with self.assertRaises(expected_error):
pc = None
try:
pc = start_processes(
name="echo",
entrypoint=echo1,
args={0: ("hello",)},
envs={0: {"RANK": "0"}},
logs_specs=DefaultLogsSpecs(log_dir=log_dir),
)
finally:
if pc:
pc.close()
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_args_env_len_mismatch
|
def test_args_env_len_mismatch(self):
cases = [
# 1 x args; 2 x envs
{
"args": {0: ("hello",)},
"envs": {0: {"RANK": "0"}, 1: {"RANK": "1"}},
},
# 2 x args; 1 x envs
{
"args": {0: ("hello",), 1: ("world",)},
"envs": {0: {"RANK": "0"}},
},
]
for kwds in cases:
args = kwds["args"]
envs = kwds["envs"]
with self.subTest(args=args, envs=envs):
with self.assertRaises(RuntimeError):
start_processes(
name="echo",
entrypoint=echo1,
args=args,
envs=envs,
log_dir=self.log_dir(),
)
|
def test_args_env_len_mismatch(self):
cases = [
# 1 x args; 2 x envs
{
"args": {0: ("hello",)},
"envs": {0: {"RANK": "0"}, 1: {"RANK": "1"}},
},
# 2 x args; 1 x envs
{
"args": {0: ("hello",), 1: ("world",)},
"envs": {0: {"RANK": "0"}},
},
]
for kwds in cases:
args = kwds["args"]
envs = kwds["envs"]
with self.subTest(args=args, envs=envs):
with self.assertRaises(RuntimeError):
start_processes(
name="echo",
entrypoint=echo1,
args=args,
envs=envs,
logs_specs=DefaultLogsSpecs(log_dir=self.log_dir()),
)
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_pcontext_wait
|
def test_pcontext_wait(self):
pc = start_processes(
name="sleep",
entrypoint=time.sleep,
args={0: (1,)},
envs={0: {}},
log_dir=self.log_dir(),
start_method="spawn",
)
self.assertIsNone(pc.wait(timeout=0.1, period=0.01))
self.assertIsNotNone(pc.wait(period=0.1))
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
|
def test_pcontext_wait(self):
pc = start_processes(
name="sleep",
entrypoint=time.sleep,
args={0: (1,)},
envs={0: {}},
logs_specs=DefaultLogsSpecs(log_dir=self.log_dir()),
start_method="spawn",
)
self.assertIsNone(pc.wait(timeout=0.1, period=0.01))
self.assertIsNotNone(pc.wait(period=0.1))
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_pcontext_wait_on_a_child_thread
|
def test_pcontext_wait_on_a_child_thread(self):
asyncio.run(asyncio.to_thread(self.test_pcontext_wait))
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_multiprocess_context_close
|
def test_multiprocess_context_close(self):
pc = start_processes(
name="sleep",
entrypoint=time.sleep,
args={0: (1,)},
envs={0: {}},
log_dir=self.log_dir(),
start_method="spawn",
)
pids = pc.pids()
pc.close()
self.assert_pids_noexist(pids)
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
|
def test_multiprocess_context_close(self):
pc = start_processes(
name="sleep",
entrypoint=time.sleep,
args={0: (1,)},
envs={0: {}},
logs_specs=DefaultLogsSpecs(log_dir=self.log_dir()),
start_method="spawn",
)
pids = pc.pids()
pc.close()
self.assert_pids_noexist(pids)
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_subprocess_context_close
|
def test_subprocess_context_close(self):
pc = start_processes(
name="sleep",
entrypoint=bin("zombie_test.py"),
args={0: (1,)},
envs={0: {}},
log_dir=self.log_dir(),
)
pids = pc.pids()
pc.close()
self.assert_pids_noexist(pids)
|
def test_subprocess_context_close(self):
pc = start_processes(
name="sleep",
entrypoint=bin("zombie_test.py"),
args={0: (1,)},
envs={0: {}},
logs_specs=DefaultLogsSpecs(log_dir=self.log_dir()),
)
pids = pc.pids()
pc.close()
self.assert_pids_noexist(pids)
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsBinaryTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/metrics/api_test.py
|
foo_1
|
def foo_1():
pass
class TestMetricsHandler(MetricHandler):
def __init__(self):
self.metric_data = {}
def emit(self, metric_data: MetricData):
self.metric_data[metric_data.name] = metric_data
class Parent(abc.ABC):
@abc.abstractmethod
def func(self):
raise NotImplementedError()
def base_func(self):
self.func()
class Child(Parent):
# need to decorate the implementation not the abstract method!
@prof
def func(self):
pass
class MetricsApiTest(TestCase):
def foo_2(self):
pass
@prof
def bar(self):
pass
@prof
def throw(self):
raise RuntimeError()
@prof(group="torchelastic")
def bar2(self):
pass
def test_get_metric_name(self):
# Note: since pytorch uses main method to launch tests,
# the module will be different between fb and oss, this
# allows keeping the module name consistent.
foo_1.__module__ = "api_test"
self.assertEqual("api_test.foo_1", _get_metric_name(foo_1))
self.assertEqual("MetricsApiTest.foo_2", _get_metric_name(self.foo_2))
def test_profile(self):
handler = TestMetricsHandler()
stream = MetricStream("torchelastic", handler)
# patch instead of configure to avoid conflicts when running tests in parallel
with mock.patch(
"torch.distributed.elastic.metrics.api.getStream", return_value=stream
):
self.bar()
self.assertEqual(1, handler.metric_data["MetricsApiTest.bar.success"].value)
self.assertNotIn("MetricsApiTest.bar.failure", handler.metric_data)
self.assertIn("MetricsApiTest.bar.duration.ms", handler.metric_data)
with self.assertRaises(RuntimeError):
self.throw()
self.assertEqual(
1, handler.metric_data["MetricsApiTest.throw.failure"].value
)
self.assertNotIn("MetricsApiTest.bar_raise.success", handler.metric_data)
self.assertIn("MetricsApiTest.throw.duration.ms", handler.metric_data)
self.bar2()
self.assertEqual(
"torchelastic",
handler.metric_data["MetricsApiTest.bar2.success"].group_name,
)
def test_inheritance(self):
handler = TestMetricsHandler()
stream = MetricStream("torchelastic", handler)
# patch instead of configure to avoid conflicts when running tests in parallel
with mock.patch(
"torch.distributed.elastic.metrics.api.getStream", return_value=stream
):
c = Child()
c.base_func()
self.assertEqual(1, handler.metric_data["Child.func.success"].value)
self.assertIn("Child.func.duration.ms", handler.metric_data)
if __name__ == "__main__":
run_tests()
|
def foo_1():
pass
class TestMetricsHandler(MetricHandler):
def __init__(self) -> None:
self.metric_data = {}
def emit(self, metric_data: MetricData):
self.metric_data[metric_data.name] = metric_data
class Parent(abc.ABC):
@abc.abstractmethod
def func(self):
raise NotImplementedError
def base_func(self):
self.func()
class Child(Parent):
# need to decorate the implementation not the abstract method!
@prof
def func(self):
pass
class MetricsApiTest(TestCase):
def foo_2(self):
pass
@prof
def bar(self):
pass
@prof
def throw(self):
raise RuntimeError
@prof(group="torchelastic")
def bar2(self):
pass
def test_get_metric_name(self):
# Note: since pytorch uses main method to launch tests,
# the module will be different between fb and oss, this
# allows keeping the module name consistent.
foo_1.__module__ = "api_test"
self.assertEqual("api_test.foo_1", _get_metric_name(foo_1))
self.assertEqual("MetricsApiTest.foo_2", _get_metric_name(self.foo_2))
def test_profile(self):
handler = TestMetricsHandler()
stream = MetricStream("torchelastic", handler)
# patch instead of configure to avoid conflicts when running tests in parallel
with mock.patch(
"torch.distributed.elastic.metrics.api.getStream", return_value=stream
):
self.bar()
self.assertEqual(1, handler.metric_data["MetricsApiTest.bar.success"].value)
self.assertNotIn("MetricsApiTest.bar.failure", handler.metric_data)
self.assertIn("MetricsApiTest.bar.duration.ms", handler.metric_data)
with self.assertRaises(RuntimeError):
self.throw()
self.assertEqual(
1, handler.metric_data["MetricsApiTest.throw.failure"].value
)
self.assertNotIn("MetricsApiTest.bar_raise.success", handler.metric_data)
self.assertIn("MetricsApiTest.throw.duration.ms", handler.metric_data)
self.bar2()
self.assertEqual(
"torchelastic",
handler.metric_data["MetricsApiTest.bar2.success"].group_name,
)
def test_inheritance(self):
handler = TestMetricsHandler()
stream = MetricStream("torchelastic", handler)
# patch instead of configure to avoid conflicts when running tests in parallel
with mock.patch(
"torch.distributed.elastic.metrics.api.getStream", return_value=stream
):
c = Child()
c.base_func()
self.assertEqual(1, handler.metric_data["Child.func.success"].value)
self.assertIn("Child.func.duration.ms", handler.metric_data)
if __name__ == "__main__":
run_tests()
|
import abc
import unittest.mock as mock
from torch.distributed.elastic.metrics.api import (
MetricData,
MetricHandler,
MetricStream,
_get_metric_name,
prof,
)
from torch.testing._internal.common_utils import run_tests, TestCase
|
import abc
import unittest.mock as mock
from torch.distributed.elastic.metrics.api import (
_get_metric_name,
MetricData,
MetricHandler,
MetricStream,
prof,
)
from torch.testing._internal.common_utils import run_tests, TestCase
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/metrics/api_test.py
|
__init__
|
def __init__(self):
self.metric_data = {}
|
def __init__(self) -> None:
self.metric_data = {}
|
import abc
import unittest.mock as mock
from torch.distributed.elastic.metrics.api import (
MetricData,
MetricHandler,
MetricStream,
_get_metric_name,
prof,
)
from torch.testing._internal.common_utils import run_tests, TestCase
class TestMetricsHandler(MetricHandler):
|
import abc
import unittest.mock as mock
from torch.distributed.elastic.metrics.api import (
_get_metric_name,
MetricData,
MetricHandler,
MetricStream,
prof,
)
from torch.testing._internal.common_utils import run_tests, TestCase
class TestMetricsHandler(MetricHandler):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_function_with_tensor
|
def test_function_with_tensor(self):
for start_method in self._start_methods:
pc = start_processes(
name="dummy_compute",
entrypoint=dummy_compute,
args={},
envs={},
log_dir=self.log_dir(),
start_method=start_method,
)
results = pc.wait()
self.assert_pids_noexist(pc.pids())
for return_value in results.return_values.values():
self.assertIsInstance(return_value, torch.Tensor)
self.assertEqual((100, 100), return_value.shape)
|
def test_function_with_tensor(self):
for start_method in self._start_methods:
pc = start_processes(
name="dummy_compute",
entrypoint=dummy_compute,
args={0: ()},
envs={0: {}},
logs_specs=DefaultLogsSpecs(log_dir=self.log_dir()),
start_method=start_method,
)
results = pc.wait()
self.assert_pids_noexist(pc.pids())
for return_value in results.return_values.values():
self.assertIsInstance(return_value, torch.Tensor)
self.assertEqual((100, 100), return_value.shape)
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_function_large_ret_val
|
def test_function_large_ret_val(self):
# python multiprocessing.queue module uses pipes and actually PipedQueues
# This means that if a single object is greater than a pipe size
# the writer process will block until reader process will start
# reading the pipe.
# This test makes a worker fn to return huge output, around ~10 MB
size = 200000
for start_method in self._start_methods:
with self.subTest(start_method=start_method):
pc = start_processes(
name="echo",
entrypoint=echo_large,
args={0: (size,), 1: (size,), 2: (size,), 3: (size,)},
envs={0: {}, 1: {}, 2: {}, 3: {}},
log_dir=self.log_dir(),
start_method=start_method,
)
results = pc.wait(period=0.1)
for i in range(pc.nprocs):
self.assertEqual(size, len(results.return_values[i]))
|
def test_function_large_ret_val(self):
# python multiprocessing.queue module uses pipes and actually PipedQueues
# This means that if a single object is greater than a pipe size
# the writer process will block until reader process will start
# reading the pipe.
# This test makes a worker fn to return huge output, around ~10 MB
size = 200000
for start_method in self._start_methods:
with self.subTest(start_method=start_method):
pc = start_processes(
logs_specs=DefaultLogsSpecs(log_dir=self.log_dir()),
name="echo",
entrypoint=echo_large,
args={0: (size,), 1: (size,), 2: (size,), 3: (size,)},
envs={0: {}, 1: {}, 2: {}, 3: {}},
start_method=start_method,
)
results = pc.wait(period=0.1)
for i in range(pc.nprocs):
self.assertEqual(size, len(results.return_values[i]))
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_function_raise
|
def test_function_raise(self):
"""
run 2x copies of echo2, raise an exception on the first
"""
RAISE = True
for start_method in self._start_methods:
with self.subTest(start_method=start_method):
log_dir = self.log_dir()
pc = start_processes(
name="echo",
entrypoint=echo2,
args={0: ("hello", RAISE), 1: ("world",)},
envs={0: {}, 1: {}},
log_dir=log_dir,
start_method=start_method,
)
results = pc.wait(period=0.1)
self.assert_pids_noexist(pc.pids())
self.assertEqual(1, len(results.failures))
self.assertFalse(results.return_values)
failure = results.failures[0]
error_file = failure.error_file
error_file_data = failure.error_file_data
self.assertEqual(1, failure.exitcode)
self.assertEqual("<N/A>", failure.signal_name())
self.assertEqual(pc.pids()[0], failure.pid)
self.assertEqual(
os.path.join(log_dir, "0", "error.json"), error_file
)
self.assertEqual(
int(error_file_data["message"]["extraInfo"]["timestamp"]),
int(failure.timestamp),
)
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
########################################
# start_processes as binary tests
########################################
|
def test_function_raise(self):
"""
run 2x copies of echo2, raise an exception on the first
"""
RAISE = True
for start_method in self._start_methods:
with self.subTest(start_method=start_method):
log_dir = self.log_dir()
pc = start_processes(
name="echo",
entrypoint=echo2,
args={0: ("hello", RAISE), 1: ("world",)},
envs={
0: {"TORCHELASTIC_RUN_ID": "run_id"},
1: {"TORCHELASTIC_RUN_ID": "run_id"},
},
logs_specs=DefaultLogsSpecs(log_dir=log_dir),
start_method=start_method,
)
results = pc.wait(period=0.1)
self.assert_pids_noexist(pc.pids())
self.assertEqual(1, len(results.failures))
self.assertFalse(results.return_values)
failure = results.failures[0]
error_file = failure.error_file
error_file_data = failure.error_file_data
self.assertEqual(1, failure.exitcode)
self.assertEqual("<N/A>", failure.signal_name())
self.assertEqual(pc.pids()[0], failure.pid)
self.assertTrue(
error_file.startswith(os.path.join(log_dir, "run_id_"))
)
self.assertTrue(error_file.endswith("attempt_0/0/error.json"))
self.assertEqual(
int(error_file_data["message"]["extraInfo"]["timestamp"]),
int(failure.timestamp),
)
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_multiprocessing_context_poll_raises_exception
|
def test_multiprocessing_context_poll_raises_exception(self):
mp_context = MultiprocessContext(
name="test_mp",
entrypoint=echo0,
args={0: (0, 1)},
envs={},
stdouts={0: {}},
stderrs={0: {}},
tee_stdouts={0: "tee_stdout"},
tee_stderrs={0: "tee_stderr"},
error_files={0: "test_file"},
start_method="spawn",
)
mp_context._pc = mock.Mock()
# Using mock since we cannot just set exitcode on process
mock_process = mock.Mock()
mock_process.exitcode = -1
mp_context._pc.processes = [mock_process]
e = mp.ProcessRaisedException(msg="test msg", error_index=0, error_pid=123)
mp_context._pc.join.side_effect = e
with mock.patch.object(mp_context, "close"):
run_result = mp_context._poll()
self.assertEqual(1, len(run_result.failures))
failure = run_result.failures[0]
self.assertEqual(
"Signal 1 (SIGHUP) received by PID 123", failure.message
)
# tests incompatible with tsan or asan, the redirect functionality does not work on macos or windows
|
def test_multiprocessing_context_poll_raises_exception(self):
mp_context = MultiprocessContext(
name="test_mp",
entrypoint=echo0,
args={0: (0, 1)},
envs={0: {}},
logs_specs=DefaultLogsSpecs(
log_dir=self.log_dir(), redirects=Std.ALL, tee=Std.ALL
),
start_method="spawn",
)
mp_context._pc = mock.Mock()
# Using mock since we cannot just set exitcode on process
mock_process = mock.Mock()
mock_process.exitcode = -1
mp_context._pc.processes = [mock_process]
e = mp.ProcessRaisedException(msg="test msg", error_index=0, error_pid=123)
mp_context._pc.join.side_effect = e
with mock.patch.object(mp_context, "close"):
run_result = mp_context._poll()
self.assertEqual(1, len(run_result.failures))
failure = run_result.failures[0]
self.assertEqual(
"Signal 1 (SIGHUP) received by PID 123", failure.message
)
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_subprocess_context_close
|
def test_subprocess_context_close(self):
pc = start_processes(
name="sleep",
entrypoint=bin("zombie_test.py"),
args={0: (1,)},
envs={0: {}},
log_dir=self.log_dir(),
)
pids = pc.pids()
pc.close()
self.assert_pids_noexist(pids)
|
def test_subprocess_context_close(self):
pc = start_processes(
name="sleep",
entrypoint=bin("zombie_test.py"),
args={0: (1,)},
envs={0: {}},
logs_specs=DefaultLogsSpecs(log_dir=self.log_dir()),
)
pids = pc.pids()
pc.close()
self.assert_pids_noexist(pids)
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsBinaryTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_binary_exit
|
def test_binary_exit(self):
FAIL = 138
pc = start_processes(
name="echo",
entrypoint=bin("echo1.py"),
args={0: ("--exitcode", FAIL, "foo"), 1: ("--exitcode", 0, "bar")},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
log_dir=self.log_dir(),
redirects={0: Std.ALL},
)
results = pc.wait(period=0.1)
self.assertTrue(results.is_failed())
self.assertEqual(1, len(results.failures))
failure = results.failures[0]
self.assertEqual(138, failure.exitcode)
self.assertEqual("<N/A>", failure.signal_name())
self.assertEqual("<NONE>", failure.error_file_data["message"])
self.assert_in_file([f"exit {FAIL} from 0"], results.stderrs[0])
self.assert_in_file([], results.stdouts[0])
self.assertFalse(results.stderrs[1])
self.assertFalse(results.stdouts[1])
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
|
def test_binary_exit(self):
FAIL = 138
pc = start_processes(
name="echo",
entrypoint=bin("echo1.py"),
args={0: ("--exitcode", FAIL, "foo"), 1: ("--exitcode", 0, "bar")},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
logs_specs=DefaultLogsSpecs(
log_dir=self.log_dir(),
redirects={0: Std.ALL},
),
)
results = pc.wait(period=0.1)
self.assertTrue(results.is_failed())
self.assertEqual(1, len(results.failures))
failure = results.failures[0]
self.assertEqual(138, failure.exitcode)
self.assertEqual("<N/A>", failure.signal_name())
self.assertEqual("<NONE>", failure.error_file_data["message"])
self.assert_in_file([f"exit {FAIL} from 0"], results.stderrs[0])
self.assert_in_file([], results.stdouts[0])
self.assertFalse(results.stderrs[1])
self.assertFalse(results.stdouts[1])
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsBinaryTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_binary_raises
|
def test_binary_raises(self):
pc = start_processes(
name="echo",
entrypoint=bin("echo2.py"),
args={0: ("--raises", "true", "foo"), 1: ("bar",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
log_dir=self.log_dir(),
)
results = pc.wait(period=0.1)
self.assert_pids_noexist(pc.pids())
self.assertTrue(results.is_failed())
self.assertEqual(1, len(results.failures))
failure = results.failures[0]
self.assertEqual(1, failure.exitcode)
self.assertEqual("<NONE>", failure.error_file_data["message"])
self.assertEqual("<N/A>", failure.signal_name())
|
def test_binary_raises(self):
pc = start_processes(
name="echo",
entrypoint=bin("echo2.py"),
args={0: ("--raises", "true", "foo"), 1: ("bar",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
logs_specs=DefaultLogsSpecs(log_dir=self.log_dir()),
)
results = pc.wait(period=0.1)
self.assert_pids_noexist(pc.pids())
self.assertTrue(results.is_failed())
self.assertEqual(1, len(results.failures))
failure = results.failures[0]
self.assertEqual(1, failure.exitcode)
self.assertEqual("<NONE>", failure.error_file_data["message"])
self.assertEqual("<N/A>", failure.signal_name())
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsBinaryTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_binary_incorrect_entrypoint
|
def test_binary_incorrect_entrypoint(self):
with self.assertRaises(FileNotFoundError):
start_processes(
name="echo",
entrypoint="does_not_exist.py",
args={0: ("foo"), 1: ("bar",)},
envs={0: {}, 1: {}},
log_dir=self.log_dir(),
)
|
def test_binary_incorrect_entrypoint(self):
with self.assertRaises(FileNotFoundError):
start_processes(
name="echo",
entrypoint="does_not_exist.py",
args={0: ("foo"), 1: ("bar",)},
envs={0: {}, 1: {}},
logs_specs=DefaultLogsSpecs(log_dir=self.log_dir()),
)
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsBinaryTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_binary_signal
|
def test_binary_signal(self):
pc = start_processes(
name="echo",
entrypoint=bin("echo3.py"),
args={0: ("--segfault", "true", "foo"), 1: ("bar",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
log_dir=self.log_dir(),
)
results = pc.wait(period=0.1)
self.assert_pids_noexist(pc.pids())
self.assertTrue(results.is_failed())
self.assertEqual(1, len(results.failures))
failure = results.failures[0]
self.assertNotEqual(signal.SIGSEGV, failure.exitcode)
if TEST_WITH_ASAN or TEST_WITH_TSAN:
# ASAN/TSAN exit code is 1.
self.assertEqual("<N/A>", failure.signal_name())
else:
self.assertEqual("SIGSEGV", failure.signal_name())
self.assertEqual("<NONE>", failure.error_file_data["message"])
|
def test_binary_signal(self):
pc = start_processes(
name="echo",
entrypoint=bin("echo3.py"),
args={0: ("--segfault", "true", "foo"), 1: ("bar",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
logs_specs=DefaultLogsSpecs(
log_dir=self.log_dir(),
),
)
results = pc.wait(period=0.1)
self.assert_pids_noexist(pc.pids())
self.assertTrue(results.is_failed())
self.assertEqual(1, len(results.failures))
failure = results.failures[0]
self.assertNotEqual(signal.SIGSEGV, failure.exitcode)
if TEST_WITH_ASAN or TEST_WITH_TSAN:
# ASAN/TSAN exit code is 1.
self.assertEqual("<N/A>", failure.signal_name())
else:
self.assertEqual("SIGSEGV", failure.signal_name())
self.assertEqual("<NONE>", failure.error_file_data["message"])
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesNotCITest(StartProcessesTest):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesNotCIAsBinaryTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_multiprocessing_context_poll_raises_exception
|
def test_multiprocessing_context_poll_raises_exception(self):
mp_context = MultiprocessContext(
name="test_mp",
entrypoint=echo0,
args={0: (0, 1)},
envs={},
stdouts={0: {}},
stderrs={0: {}},
tee_stdouts={0: "tee_stdout"},
tee_stderrs={0: "tee_stderr"},
error_files={0: "test_file"},
start_method="spawn",
)
mp_context._pc = mock.Mock()
# Using mock since we cannot just set exitcode on process
mock_process = mock.Mock()
mock_process.exitcode = -1
mp_context._pc.processes = [mock_process]
e = mp.ProcessRaisedException(msg="test msg", error_index=0, error_pid=123)
mp_context._pc.join.side_effect = e
with mock.patch.object(mp_context, "close"):
run_result = mp_context._poll()
self.assertEqual(1, len(run_result.failures))
failure = run_result.failures[0]
self.assertEqual(
"Signal 1 (SIGHUP) received by PID 123", failure.message
)
# tests incompatible with tsan or asan, the redirect functionality does not work on macos or windows
|
def test_multiprocessing_context_poll_raises_exception(self):
mp_context = MultiprocessContext(
name="test_mp",
entrypoint=echo0,
args={0: (0, 1)},
envs={0: {}},
logs_specs=DefaultLogsSpecs(
log_dir=self.log_dir(), redirects=Std.ALL, tee=Std.ALL
),
start_method="spawn",
)
mp_context._pc = mock.Mock()
# Using mock since we cannot just set exitcode on process
mock_process = mock.Mock()
mock_process.exitcode = -1
mp_context._pc.processes = [mock_process]
e = mp.ProcessRaisedException(msg="test msg", error_index=0, error_pid=123)
mp_context._pc.join.side_effect = e
with mock.patch.object(mp_context, "close"):
run_result = mp_context._poll()
self.assertEqual(1, len(run_result.failures))
failure = run_result.failures[0]
self.assertEqual(
"Signal 1 (SIGHUP) received by PID 123", failure.message
)
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesTest(TestCase):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_function
|
def test_function(self):
for start_method, redirs in product(
self._start_methods, redirects_oss_test()
):
with self.subTest(start_method=start_method, redirs=redirs):
pc = start_processes(
name="echo",
entrypoint=echo1,
args={0: ("hello",), 1: ("hello",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
log_dir=self.log_dir(),
start_method=start_method,
redirects=redirs,
)
results = pc.wait(period=0.1)
nprocs = pc.nprocs
self.assert_pids_noexist(pc.pids())
self.assertEqual(
{i: f"hello_{i}" for i in range(nprocs)}, results.return_values
)
for i in range(nprocs):
if redirs & Std.OUT != Std.OUT:
self.assertFalse(results.stdouts[i])
if redirs & Std.ERR != Std.ERR:
self.assertFalse(results.stderrs[i])
if redirs & Std.OUT == Std.OUT:
self.assert_in_file(
[f"hello stdout from {i}"], results.stdouts[i]
)
if redirs & Std.ERR == Std.ERR:
self.assert_in_file(
[f"hello stderr from {i}"], results.stderrs[i]
)
|
def test_function(self):
for start_method, redirs in product(
self._start_methods, redirects_oss_test()
):
with self.subTest(start_method=start_method, redirs=redirs):
pc = start_processes(
name="echo",
entrypoint=echo1,
args={0: ("hello",), 1: ("hello",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
logs_specs=DefaultLogsSpecs(
log_dir=self.log_dir(),
redirects=redirs,
),
start_method=start_method,
)
results = pc.wait(period=0.1)
nprocs = pc.nprocs
self.assert_pids_noexist(pc.pids())
self.assertEqual(
{i: f"hello_{i}" for i in range(nprocs)}, results.return_values
)
for i in range(nprocs):
if redirs & Std.OUT != Std.OUT:
self.assertFalse(results.stdouts[i])
if redirs & Std.ERR != Std.ERR:
self.assertFalse(results.stderrs[i])
if redirs & Std.OUT == Std.OUT:
self.assert_in_file(
[f"hello stdout from {i}"], results.stdouts[i]
)
if redirs & Std.ERR == Std.ERR:
self.assert_in_file(
[f"hello stderr from {i}"], results.stderrs[i]
)
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesListTest(StartProcessesTest):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesListAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_binary
|
def test_binary(self):
for redirs in redirects_oss_test():
with self.subTest(redirs=redirs):
pc = start_processes(
name="echo",
entrypoint=bin("echo1.py"),
args={0: ("hello",), 1: ("hello",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
log_dir=self.log_dir(),
redirects=redirs,
)
results = pc.wait(period=0.1)
self.assert_pids_noexist(pc.pids())
# currently binaries return {rank: None}
self.assertEqual(2, len(results.return_values))
self.assertFalse(results.is_failed())
nprocs = pc.nprocs
for i in range(nprocs):
if redirs & Std.OUT != Std.OUT:
self.assertFalse(results.stdouts[i])
if redirs & Std.ERR != Std.ERR:
self.assertFalse(results.stderrs[i])
if redirs & Std.OUT == Std.OUT:
self.assert_in_file(
[f"hello stdout from {i}"], results.stdouts[i]
)
if redirs & Std.ERR == Std.ERR:
self.assert_in_file(
[f"hello stderr from {i}"], results.stderrs[i]
)
|
def test_binary(self):
for redirs in redirects_oss_test():
with self.subTest(redirs=redirs):
pc = start_processes(
name="echo",
entrypoint=bin("echo1.py"),
args={0: ("hello",), 1: ("hello",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
logs_specs=DefaultLogsSpecs(
log_dir=self.log_dir(),
redirects=redirs,
),
log_line_prefixes={0: "[rank0]:", 1: "[rank1]:"},
)
results = pc.wait(period=0.1)
self.assert_pids_noexist(pc.pids())
# currently binaries return {rank: None}
self.assertEqual(2, len(results.return_values))
self.assertFalse(results.is_failed())
nprocs = pc.nprocs
for i in range(nprocs):
if redirs & Std.OUT != Std.OUT:
self.assertFalse(results.stdouts[i])
if redirs & Std.ERR != Std.ERR:
self.assertFalse(results.stderrs[i])
if redirs & Std.OUT == Std.OUT:
self.assert_in_file(
[f"hello stdout from {i}"], results.stdouts[i]
)
if redirs & Std.ERR == Std.ERR:
self.assert_in_file(
[f"hello stderr from {i}"], results.stderrs[i]
)
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesListTest(StartProcessesTest):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesListAsBinaryTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_binary_redirect_and_tee
|
def test_binary_redirect_and_tee(self):
pc = start_processes(
name="trainer",
entrypoint=bin("echo1.py"),
args={0: ("hello",), 1: ("world",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
log_dir=self.log_dir(),
start_method="spawn",
redirects={0: Std.ERR, 1: Std.NONE},
tee={0: Std.OUT, 1: Std.ERR},
)
result = pc.wait()
self.assertFalse(result.is_failed())
self.assert_in_file(["hello stdout from 0"], pc.stdouts[0])
self.assert_in_file(["hello stderr from 0"], pc.stderrs[0])
self.assert_in_file(["world stderr from 1"], pc.stderrs[1])
self.assertFalse(pc.stdouts[1])
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
# tests incompatible with tsan or asan, the redirect functionality does not work on macos or windows
|
def test_binary_redirect_and_tee(self):
pc = start_processes(
name="trainer",
entrypoint=bin("echo1.py"),
args={0: ("hello",), 1: ("world",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
logs_specs=DefaultLogsSpecs(
log_dir=self.log_dir(),
redirects={0: Std.ERR, 1: Std.NONE},
tee={0: Std.OUT, 1: Std.ERR},
),
log_line_prefixes={0: "[rank0]:", 1: "[rank1]:"},
start_method="spawn",
)
result = pc.wait()
self.assertFalse(result.is_failed())
self.assert_in_file(["hello stdout from 0"], pc.stdouts[0])
self.assert_in_file(["hello stderr from 0"], pc.stderrs[0])
self.assert_in_file(["world stderr from 1"], pc.stderrs[1])
self.assertFalse(pc.stdouts[1])
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
# tests incompatible with tsan or asan, the redirect functionality does not work on macos or windows
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesListTest(StartProcessesTest):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesListAsBinaryTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_binary_signal
|
def test_binary_signal(self):
pc = start_processes(
name="echo",
entrypoint=bin("echo3.py"),
args={0: ("--segfault", "true", "foo"), 1: ("bar",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
log_dir=self.log_dir(),
)
results = pc.wait(period=0.1)
self.assert_pids_noexist(pc.pids())
self.assertTrue(results.is_failed())
self.assertEqual(1, len(results.failures))
failure = results.failures[0]
self.assertNotEqual(signal.SIGSEGV, failure.exitcode)
if TEST_WITH_ASAN or TEST_WITH_TSAN:
# ASAN/TSAN exit code is 1.
self.assertEqual("<N/A>", failure.signal_name())
else:
self.assertEqual("SIGSEGV", failure.signal_name())
self.assertEqual("<NONE>", failure.error_file_data["message"])
|
def test_binary_signal(self):
pc = start_processes(
name="echo",
entrypoint=bin("echo3.py"),
args={0: ("--segfault", "true", "foo"), 1: ("bar",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
logs_specs=DefaultLogsSpecs(
log_dir=self.log_dir(),
),
)
results = pc.wait(period=0.1)
self.assert_pids_noexist(pc.pids())
self.assertTrue(results.is_failed())
self.assertEqual(1, len(results.failures))
failure = results.failures[0]
self.assertNotEqual(signal.SIGSEGV, failure.exitcode)
if TEST_WITH_ASAN or TEST_WITH_TSAN:
# ASAN/TSAN exit code is 1.
self.assertEqual("<N/A>", failure.signal_name())
else:
self.assertEqual("SIGSEGV", failure.signal_name())
self.assertEqual("<NONE>", failure.error_file_data["message"])
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesNotCITest(StartProcessesTest):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesNotCIAsBinaryTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_function_redirect_and_tee
|
def test_function_redirect_and_tee(self):
for start_method in self._start_methods:
with self.subTest(start_method=start_method):
log_dir = self.log_dir()
pc = start_processes(
name="trainer",
entrypoint=echo1,
args={0: ("hello",), 1: ("world",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
log_dir=log_dir,
start_method="spawn",
redirects={0: Std.ERR, 1: Std.NONE},
tee={0: Std.OUT, 1: Std.ERR},
)
result = pc.wait()
self.assertFalse(result.is_failed())
self.assert_in_file(["hello stdout from 0"], pc.stdouts[0])
self.assert_in_file(["hello stderr from 0"], pc.stderrs[0])
self.assert_in_file(["world stderr from 1"], pc.stderrs[1])
self.assertFalse(pc.stdouts[1])
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
|
def test_function_redirect_and_tee(self):
for start_method in self._start_methods:
with self.subTest(start_method=start_method):
pc = start_processes(
name="trainer",
entrypoint=echo1,
args={0: ("hello",), 1: ("world",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
logs_specs=DefaultLogsSpecs(
log_dir=self.log_dir(),
redirects={0: Std.ERR, 1: Std.NONE},
tee={0: Std.OUT, 1: Std.ERR},
),
start_method="spawn",
)
result = pc.wait()
self.assertFalse(result.is_failed())
self.assert_in_file(["hello stdout from 0"], pc.stdouts[0])
self.assert_in_file(["hello stderr from 0"], pc.stderrs[0])
self.assert_in_file(["world stderr from 1"], pc.stderrs[1])
self.assertFalse(pc.stdouts[1])
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesNotCITest(StartProcessesTest):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesNotCIAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_function
|
def test_function(self):
for start_method, redirs in product(
self._start_methods, redirects_oss_test()
):
with self.subTest(start_method=start_method, redirs=redirs):
pc = start_processes(
name="echo",
entrypoint=echo1,
args={0: ("hello",), 1: ("hello",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
log_dir=self.log_dir(),
start_method=start_method,
redirects=redirs,
)
results = pc.wait(period=0.1)
nprocs = pc.nprocs
self.assert_pids_noexist(pc.pids())
self.assertEqual(
{i: f"hello_{i}" for i in range(nprocs)}, results.return_values
)
for i in range(nprocs):
if redirs & Std.OUT != Std.OUT:
self.assertFalse(results.stdouts[i])
if redirs & Std.ERR != Std.ERR:
self.assertFalse(results.stderrs[i])
if redirs & Std.OUT == Std.OUT:
self.assert_in_file(
[f"hello stdout from {i}"], results.stdouts[i]
)
if redirs & Std.ERR == Std.ERR:
self.assert_in_file(
[f"hello stderr from {i}"], results.stderrs[i]
)
|
def test_function(self):
for start_method, redirs in product(
self._start_methods, redirects_oss_test()
):
with self.subTest(start_method=start_method, redirs=redirs):
pc = start_processes(
name="echo",
entrypoint=echo1,
args={0: ("hello",), 1: ("hello",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
logs_specs=DefaultLogsSpecs(
log_dir=self.log_dir(),
redirects=redirs,
),
start_method=start_method,
)
results = pc.wait(period=0.1)
nprocs = pc.nprocs
self.assert_pids_noexist(pc.pids())
self.assertEqual(
{i: f"hello_{i}" for i in range(nprocs)}, results.return_values
)
for i in range(nprocs):
if redirs & Std.OUT != Std.OUT:
self.assertFalse(results.stdouts[i])
if redirs & Std.ERR != Std.ERR:
self.assertFalse(results.stderrs[i])
if redirs & Std.OUT == Std.OUT:
self.assert_in_file(
[f"hello stdout from {i}"], results.stdouts[i]
)
if redirs & Std.ERR == Std.ERR:
self.assert_in_file(
[f"hello stderr from {i}"], results.stderrs[i]
)
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesListTest(StartProcessesTest):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesListAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/api_test.py
|
test_function_exit
|
def test_function_exit(self):
"""
run 2x copies of echo1 fail (exit) the first
functions that exit from python do not generate an error file
(even if they are decorated with @record)
"""
FAIL = 138
for start_method in self._start_methods:
with self.subTest(start_method=start_method):
log_dir = self.log_dir()
pc = start_processes(
name="echo",
entrypoint=echo1,
args={0: ("hello", FAIL), 1: ("hello",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
log_dir=log_dir,
start_method=start_method,
redirects={0: Std.ERR},
)
results = pc.wait(period=0.1)
self.assert_pids_noexist(pc.pids())
self.assertTrue(results.is_failed())
self.assertEqual(1, len(results.failures))
self.assertFalse(results.return_values)
failure = results.failures[0]
error_file = failure.error_file
self.assertEqual(FAIL, failure.exitcode)
self.assertEqual("<N/A>", failure.signal_name())
self.assertEqual(pc.pids()[0], failure.pid)
self.assertEqual("<N/A>", error_file)
self.assertEqual(
"To enable traceback see: https://pytorch.org/docs/stable/elastic/errors.html",
failure.message,
)
self.assertLessEqual(failure.timestamp, int(time.time()))
self.assert_in_file([f"exit {FAIL} from 0"], results.stderrs[0])
self.assertFalse(results.stdouts[0])
self.assertFalse(results.stderrs[1])
self.assertFalse(results.stdouts[1])
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
|
def test_function_exit(self):
"""
run 2x copies of echo1 fail (exit) the first
functions that exit from python do not generate an error file
(even if they are decorated with @record)
"""
FAIL = 138
for start_method in self._start_methods:
with self.subTest(start_method=start_method):
pc = start_processes(
name="echo",
entrypoint=echo1,
args={0: ("hello", FAIL), 1: ("hello",)},
envs={0: {"RANK": "0"}, 1: {"RANK": "1"}},
logs_specs=DefaultLogsSpecs(
log_dir=self.log_dir(),
redirects={0: Std.ERR},
),
start_method=start_method,
)
results = pc.wait(period=0.1)
self.assert_pids_noexist(pc.pids())
self.assertTrue(results.is_failed())
self.assertEqual(1, len(results.failures))
self.assertFalse(results.return_values)
failure = results.failures[0]
error_file = failure.error_file
self.assertEqual(FAIL, failure.exitcode)
self.assertEqual("<N/A>", failure.signal_name())
self.assertEqual(pc.pids()[0], failure.pid)
self.assertEqual("<N/A>", error_file)
self.assertEqual(
"To enable traceback see: https://pytorch.org/docs/stable/elastic/errors.html",
failure.message,
)
self.assertLessEqual(failure.timestamp, int(time.time()))
self.assert_in_file([f"exit {FAIL} from 0"], results.stderrs[0])
self.assertFalse(results.stdouts[0])
self.assertFalse(results.stderrs[1])
self.assertFalse(results.stdouts[1])
self.assertTrue(pc._stderr_tail.stopped())
self.assertTrue(pc._stdout_tail.stopped())
|
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
_validate_full_rank,
_wrap,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
run_tests,
sandcastle_skip_if,
)
class StartProcessesNotCITest(StartProcessesTest):
|
import asyncio
import ctypes
import multiprocessing
import os
import shutil
import signal
import sys
import tempfile
import time
from itertools import product
from typing import Callable, Dict, List, Union
from unittest import mock
import torch
import torch.multiprocessing as mp
from torch.distributed.elastic.multiprocessing import ProcessFailure, start_processes
from torch.distributed.elastic.multiprocessing.api import (
_validate_full_rank,
_wrap,
DefaultLogsSpecs,
MultiprocessContext,
RunProcsResult,
SignalException,
Std,
to_map,
)
from torch.distributed.elastic.multiprocessing.errors import ErrorHandler
from torch.testing._internal.common_utils import (
IS_CI,
IS_MACOS,
IS_WINDOWS,
NO_MULTIPROCESSING_SPAWN,
run_tests,
skip_but_pass_in_sandcastle_if,
skip_if_pytest,
TEST_WITH_ASAN,
TEST_WITH_DEV_DBG_ASAN,
TEST_WITH_TSAN,
TestCase,
)
class StartProcessesNotCIAsFuncTest(_StartProcessesTest):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/errors/api_test.py
|
test_record
|
def test_record(self):
with mock.patch.dict(
os.environ, {"TORCHELASTIC_ERROR_FILE": self.test_error_file}
):
with self.assertRaises(SentinelError):
raise_exception_fn()
with open(self.test_error_file, "r") as fp:
err = json.load(fp)
self.assertIsNotNone(err["message"]["message"])
self.assertIsNotNone(err["message"]["extraInfo"]["py_callstack"])
self.assertIsNotNone(err["message"]["extraInfo"]["timestamp"])
|
def test_record(self):
with mock.patch.dict(
os.environ, {"TORCHELASTIC_ERROR_FILE": self.test_error_file}
):
with self.assertRaises(SentinelError):
raise_exception_fn()
with open(self.test_error_file) as fp:
err = json.load(fp)
self.assertIsNotNone(err["message"]["message"])
self.assertIsNotNone(err["message"]["extraInfo"]["py_callstack"])
self.assertIsNotNone(err["message"]["extraInfo"]["timestamp"])
|
import json
import os
import shutil
import signal
import tempfile
import unittest
from unittest import mock
from torch.distributed.elastic.multiprocessing.errors import (
ChildFailedError,
ProcessFailure,
record,
)
from torch.distributed.elastic.multiprocessing.errors.error_handler import ErrorHandler
class ApiTest(unittest.TestCase):
|
import json
import os
import shutil
import signal
import tempfile
import unittest
from unittest import mock
from torch.distributed.elastic.multiprocessing.errors import (
ChildFailedError,
ProcessFailure,
record,
)
from torch.distributed.elastic.multiprocessing.errors.error_handler import ErrorHandler
class ApiTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/errors/api_test.py
|
test_record_system_exit
|
def test_record_system_exit(self):
with mock.patch.dict(os.environ, {}):
raise_system_exit_exception_fn(exit_code=0)
# no error file should have been generated
self.assertFalse(os.path.isfile(self.test_error_file))
|
import json
import os
import shutil
import signal
import tempfile
import unittest
from unittest import mock
from torch.distributed.elastic.multiprocessing.errors import (
ChildFailedError,
ProcessFailure,
record,
)
from torch.distributed.elastic.multiprocessing.errors.error_handler import ErrorHandler
class ApiTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/elastic/multiprocessing/errors/api_test.py
|
test_record_system_exit_erronr
|
def test_record_system_exit_erronr(self):
with mock.patch.dict(os.environ, {}):
with self.assertRaises(SystemExit):
raise_system_exit_exception_fn()
# no error file should have been generated
self.assertFalse(os.path.isfile(self.test_error_file))
|
import json
import os
import shutil
import signal
import tempfile
import unittest
from unittest import mock
from torch.distributed.elastic.multiprocessing.errors import (
ChildFailedError,
ProcessFailure,
record,
)
from torch.distributed.elastic.multiprocessing.errors.error_handler import ErrorHandler
class ApiTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
added
|
||
torch
|
test/distributed/elastic/multiprocessing/errors/api_test.py
|
test_record_child_failure
|
def test_record_child_failure(self):
trainer_log_dir = os.path.join(self.test_dir, "trainer", "0")
os.makedirs(trainer_log_dir)
trainer_error_file = os.path.join(trainer_log_dir, "error.json")
with mock.patch.dict(
os.environ, {"TORCHELASTIC_ERROR_FILE": self.test_error_file}
):
with self.assertRaises(ChildFailedError) as cm:
raise_child_failure_error_fn("trainer", trainer_error_file)
pf = cm.exception.get_first_failure()[1]
# compare worker error file with reply file and overridden error code
expect = json.load(open(pf.error_file, "r"))
expect["message"]["errorCode"] = pf.exitcode
actual = json.load(open(self.test_error_file, "r"))
self.assertTrue(
json.dumps(expect, sort_keys=True),
json.dumps(actual, sort_keys=True),
)
|
def test_record_child_failure(self):
trainer_log_dir = os.path.join(self.test_dir, "trainer", "0")
os.makedirs(trainer_log_dir)
trainer_error_file = os.path.join(trainer_log_dir, "error.json")
with mock.patch.dict(
os.environ, {"TORCHELASTIC_ERROR_FILE": self.test_error_file}
):
with self.assertRaises(ChildFailedError) as cm:
raise_child_failure_error_fn("trainer", trainer_error_file)
pf = cm.exception.get_first_failure()[1]
# compare worker error file with reply file and overridden error code
expect = json.load(open(pf.error_file))
expect["message"]["errorCode"] = pf.exitcode
actual = json.load(open(self.test_error_file))
self.assertTrue(
json.dumps(expect, sort_keys=True),
json.dumps(actual, sort_keys=True),
)
|
import json
import os
import shutil
import signal
import tempfile
import unittest
from unittest import mock
from torch.distributed.elastic.multiprocessing.errors import (
ChildFailedError,
ProcessFailure,
record,
)
from torch.distributed.elastic.multiprocessing.errors.error_handler import ErrorHandler
class ApiTest(unittest.TestCase):
|
import json
import os
import shutil
import signal
import tempfile
import unittest
from unittest import mock
from torch.distributed.elastic.multiprocessing.errors import (
ChildFailedError,
ProcessFailure,
record,
)
from torch.distributed.elastic.multiprocessing.errors.error_handler import ErrorHandler
class ApiTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/errors/error_handler_test.py
|
test_record_exception
|
def test_record_exception(self):
with patch.dict(os.environ, {"TORCHELASTIC_ERROR_FILE": self.test_error_file}):
eh = ErrorHandler()
eh.initialize()
try:
raise_exception_fn()
except Exception as e:
eh.record_exception(e)
with open(self.test_error_file, "r") as fp:
err = json.load(fp)
# error file content example:
# {
# "message": {
# "message": "RuntimeError: foobar",
# "extraInfo": {
# "py_callstack": "Traceback (most recent call last):\n <... OMITTED ...>",
# "timestamp": "1605774851"
# }
# }
self.assertIsNotNone(err["message"]["message"])
self.assertIsNotNone(err["message"]["extraInfo"]["py_callstack"])
self.assertIsNotNone(err["message"]["extraInfo"]["timestamp"])
|
def test_record_exception(self):
with patch.dict(os.environ, {"TORCHELASTIC_ERROR_FILE": self.test_error_file}):
eh = ErrorHandler()
eh.initialize()
try:
raise_exception_fn()
except Exception as e:
eh.record_exception(e)
with open(self.test_error_file) as fp:
err = json.load(fp)
# error file content example:
# {
# "message": {
# "message": "RuntimeError: foobar",
# "extraInfo": {
# "py_callstack": "Traceback (most recent call last):\n <... OMITTED ...>",
# "timestamp": "1605774851"
# }
# }
self.assertIsNotNone(err["message"]["message"])
self.assertIsNotNone(err["message"]["extraInfo"]["py_callstack"])
self.assertIsNotNone(err["message"]["extraInfo"]["timestamp"])
|
import filecmp
import json
import os
import shutil
import tempfile
import unittest
from unittest.mock import patch
from torch.distributed.elastic.multiprocessing.errors.error_handler import ErrorHandler
from torch.distributed.elastic.multiprocessing.errors.handlers import get_error_handler
class ErrorHandlerTest(unittest.TestCase):
|
import filecmp
import json
import os
import shutil
import tempfile
import unittest
from unittest.mock import patch
from torch.distributed.elastic.multiprocessing.errors.error_handler import ErrorHandler
from torch.distributed.elastic.multiprocessing.errors.handlers import get_error_handler
class ErrorHandlerTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/redirects_test.py
|
test_redirect_stdout
|
def test_redirect_stdout(self):
stdout_log = os.path.join(self.test_dir, "stdout.log")
# printing to stdout before redirect should go to console not stdout.log
print("foo first from python")
libc.printf(b"foo first from c\n")
os.system("echo foo first from cmd")
with redirect_stdout(stdout_log):
print("foo from python")
libc.printf(b"foo from c\n")
os.system("echo foo from cmd")
# make sure stdout is restored
print("foo again from python")
libc.printf(b"foo again from c\n")
os.system("echo foo again from cmd")
with open(stdout_log, "r") as f:
# since we print from python, c, cmd -> the stream is not ordered
# do a set comparison
lines = set(f.readlines())
self.assertEqual(
{"foo from python\n", "foo from c\n", "foo from cmd\n"}, lines
)
|
def test_redirect_stdout(self):
stdout_log = os.path.join(self.test_dir, "stdout.log")
# printing to stdout before redirect should go to console not stdout.log
print("foo first from python")
libc.printf(b"foo first from c\n")
os.system("echo foo first from cmd")
with redirect_stdout(stdout_log):
print("foo from python")
libc.printf(b"foo from c\n")
os.system("echo foo from cmd")
# make sure stdout is restored
print("foo again from python")
libc.printf(b"foo again from c\n")
os.system("echo foo again from cmd")
with open(stdout_log) as f:
# since we print from python, c, cmd -> the stream is not ordered
# do a set comparison
lines = set(f.readlines())
self.assertEqual(
{"foo from python\n", "foo from c\n", "foo from cmd\n"}, lines
)
|
import ctypes
import os
import shutil
import sys
import tempfile
import unittest
from torch.distributed.elastic.multiprocessing.redirects import (
redirect,
redirect_stderr,
redirect_stdout,
)
libc = ctypes.CDLL("libc.so.6")
c_stderr = ctypes.c_void_p.in_dll(libc, "stderr")
class RedirectsTest(unittest.TestCase):
|
import ctypes
import os
import shutil
import sys
import tempfile
import unittest
from torch.distributed.elastic.multiprocessing.redirects import (
redirect,
redirect_stderr,
redirect_stdout,
)
libc = ctypes.CDLL("libc.so.6")
c_stderr = ctypes.c_void_p.in_dll(libc, "stderr")
class RedirectsTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/redirects_test.py
|
test_redirect_stderr
|
def test_redirect_stderr(self):
stderr_log = os.path.join(self.test_dir, "stderr.log")
print("bar first from python")
libc.fprintf(c_stderr, b"bar first from c\n")
os.system("echo bar first from cmd 1>&2")
with redirect_stderr(stderr_log):
print("bar from python", file=sys.stderr)
libc.fprintf(c_stderr, b"bar from c\n")
os.system("echo bar from cmd 1>&2")
print("bar again from python")
libc.fprintf(c_stderr, b"bar again from c\n")
os.system("echo bar again from cmd 1>&2")
with open(stderr_log, "r") as f:
lines = set(f.readlines())
self.assertEqual(
{"bar from python\n", "bar from c\n", "bar from cmd\n"}, lines
)
|
def test_redirect_stderr(self):
stderr_log = os.path.join(self.test_dir, "stderr.log")
print("bar first from python")
libc.fprintf(c_stderr, b"bar first from c\n")
os.system("echo bar first from cmd 1>&2")
with redirect_stderr(stderr_log):
print("bar from python", file=sys.stderr)
libc.fprintf(c_stderr, b"bar from c\n")
os.system("echo bar from cmd 1>&2")
print("bar again from python")
libc.fprintf(c_stderr, b"bar again from c\n")
os.system("echo bar again from cmd 1>&2")
with open(stderr_log) as f:
lines = set(f.readlines())
self.assertEqual(
{"bar from python\n", "bar from c\n", "bar from cmd\n"}, lines
)
|
import ctypes
import os
import shutil
import sys
import tempfile
import unittest
from torch.distributed.elastic.multiprocessing.redirects import (
redirect,
redirect_stderr,
redirect_stdout,
)
libc = ctypes.CDLL("libc.so.6")
c_stderr = ctypes.c_void_p.in_dll(libc, "stderr")
class RedirectsTest(unittest.TestCase):
|
import ctypes
import os
import shutil
import sys
import tempfile
import unittest
from torch.distributed.elastic.multiprocessing.redirects import (
redirect,
redirect_stderr,
redirect_stdout,
)
libc = ctypes.CDLL("libc.so.6")
c_stderr = ctypes.c_void_p.in_dll(libc, "stderr")
class RedirectsTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
torch
|
test/distributed/elastic/multiprocessing/redirects_test.py
|
test_redirect_both
|
def test_redirect_both(self):
stdout_log = os.path.join(self.test_dir, "stdout.log")
stderr_log = os.path.join(self.test_dir, "stderr.log")
print("first stdout from python")
libc.printf(b"first stdout from c\n")
print("first stderr from python", file=sys.stderr)
libc.fprintf(c_stderr, b"first stderr from c\n")
with redirect_stdout(stdout_log), redirect_stderr(stderr_log):
print("redir stdout from python")
print("redir stderr from python", file=sys.stderr)
libc.printf(b"redir stdout from c\n")
libc.fprintf(c_stderr, b"redir stderr from c\n")
print("again stdout from python")
libc.fprintf(c_stderr, b"again stderr from c\n")
with open(stdout_log, "r") as f:
lines = set(f.readlines())
self.assertEqual(
{"redir stdout from python\n", "redir stdout from c\n"}, lines
)
with open(stderr_log, "r") as f:
lines = set(f.readlines())
self.assertEqual(
{"redir stderr from python\n", "redir stderr from c\n"}, lines
)
|
def test_redirect_both(self):
stdout_log = os.path.join(self.test_dir, "stdout.log")
stderr_log = os.path.join(self.test_dir, "stderr.log")
print("first stdout from python")
libc.printf(b"first stdout from c\n")
print("first stderr from python", file=sys.stderr)
libc.fprintf(c_stderr, b"first stderr from c\n")
with redirect_stdout(stdout_log), redirect_stderr(stderr_log):
print("redir stdout from python")
print("redir stderr from python", file=sys.stderr)
libc.printf(b"redir stdout from c\n")
libc.fprintf(c_stderr, b"redir stderr from c\n")
print("again stdout from python")
libc.fprintf(c_stderr, b"again stderr from c\n")
with open(stdout_log) as f:
lines = set(f.readlines())
self.assertEqual(
{"redir stdout from python\n", "redir stdout from c\n"}, lines
)
with open(stderr_log) as f:
lines = set(f.readlines())
self.assertEqual(
{"redir stderr from python\n", "redir stderr from c\n"}, lines
)
|
import ctypes
import os
import shutil
import sys
import tempfile
import unittest
from torch.distributed.elastic.multiprocessing.redirects import (
redirect,
redirect_stderr,
redirect_stdout,
)
libc = ctypes.CDLL("libc.so.6")
c_stderr = ctypes.c_void_p.in_dll(libc, "stderr")
class RedirectsTest(unittest.TestCase):
|
import ctypes
import os
import shutil
import sys
import tempfile
import unittest
from torch.distributed.elastic.multiprocessing.redirects import (
redirect,
redirect_stderr,
redirect_stdout,
)
libc = ctypes.CDLL("libc.so.6")
c_stderr = ctypes.c_void_p.in_dll(libc, "stderr")
class RedirectsTest(unittest.TestCase):
|
c263bd43e8e8502d4726643bc6fd046f0130ac0e
|
32f585d9346e316e554c8d9bf7548af9f62141fc
|
modified
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.