code: def test_sharding_zch_mch_mc_ebc(self, backend: str) -> None:
      WORLD_SIZE = 2
  
      embedding_bag_config = [
          EmbeddingBagConfig(
              name="table_0",
              feature_names=["feature_0"],
              embedding_dim=8,
              num_embeddings=16,
          ),
          EmbeddingBagConfig(
              name="table_1",
              feature_names=["feature_1"],
              embedding_dim=8,
              num_embeddings=32,
          ),
      ]
  
      kjt_input_per_rank = [  # noqa
          KeyedJaggedTensor.from_lengths_sync(
              keys=["feature_0", "feature_1"],
              values=torch.LongTensor(
                  [1000, 2000, 1001, 2000, 2001, 2002],
              ),
              lengths=torch.LongTensor([1, 1, 1, 1, 1, 1]),
              weights=None,
          ),
          KeyedJaggedTensor.from_lengths_sync(
              keys=["feature_0", "feature_1"],
              values=torch.LongTensor(
                  [
                      1000,
                      1002,
                      1004,
                      2000,
                      2002,
                      2004,
                  ],
              ),
              lengths=torch.LongTensor([1, 1, 1, 1, 1, 1]),
              weights=None,
          ),
      ]
  
      kjt_out_per_iter_per_rank: List[List[KeyedJaggedTensor]] = []
      kjt_out_per_iter_per_rank.append(
          [
              KeyedJaggedTensor.from_lengths_sync(
                  keys=["feature_0", "feature_1"],
                  values=torch.LongTensor(
                      [
                          4,  # 1000 % 4 + 4
                          12,  # 2000 % 4 + 12
                          5,  # 1001 % 4 + 4
                          28,  # 2000 % 4 + 28
                          29,  # 2001 % 4 + 28
                          30,  # 2002 % 4 + 28
                      ],
                  ),
                  lengths=torch.LongTensor([1, 1, 1, 1, 1, 1]),
                  weights=None,
              ),
              KeyedJaggedTensor.from_lengths_sync(
                  keys=["feature_0", "feature_1"],
                  values=torch.LongTensor(
                      [
                          4,  # 1000 % 4 + 4
                          6,  # 1002 % 4 + 4
                          4,  # 1004 % 4 + 4
                          28,  # 2000 % 4 + 28
                          30,  # 2002 % 4 + 28
                          28,  # 2004 % 4 + 28
                      ],
                  ),
                  lengths=torch.LongTensor([1, 1, 1, 1, 1, 1]),
                  weights=None,
              ),
          ]
      )
      # TODO: cleanup sorting so more dedugable/logical initial fill
  
      kjt_out_per_iter_per_rank.append(
          [
              KeyedJaggedTensor.from_lengths_sync(
                  keys=["feature_0", "feature_1"],
                  values=torch.LongTensor(
                      [
                          0,  # zch for 1000
                          10,  # zch for 2000
                          1,  # zch for 1001
                          23,  # zch for 2000
                          25,  # zch for 2001
                          24,  # zch for 2002
                      ],
                  ),
                  lengths=torch.LongTensor([1, 1, 1, 1, 1, 1]),
                  weights=None,
              ),
              KeyedJaggedTensor.from_lengths_sync(
                  keys=["feature_0", "feature_1"],
                  values=torch.LongTensor(
                      [
                          0,  # zch for 1000
                          2,  # zch for 1002
                          4,  # 1004 % 4 + 4
                          23,  # zch for 2000
                          24,  # zch for 2002
                          26,  # zch for 2004
                      ],
                  ),
                  lengths=torch.LongTensor([1, 1, 1, 1, 1, 1]),
                  weights=None,
              ),
          ]
      )
  
      self._run_multi_process_test(
          callable=_test_sharding_and_remapping,
          world_size=WORLD_SIZE,
          tables=embedding_bag_config,
          mch_size=8,
          kjt_input_per_rank=kjt_input_per_rank,
          kjt_out_per_iter_per_rank=kjt_out_per_iter_per_rank,
          sharder=ManagedCollisionEmbeddingBagCollectionSharder(),
          backend=backend,
      )
  
imports: import copy
  import unittest
  from typing import Dict, List, Optional, Tuple
  import torch
  import torch.nn
  from hypothesis import given, settings, strategies
  from torchrec.distributed.embeddingbag import ShardedEmbeddingBagCollection
  from torchrec.distributed.mc_embeddingbag import ManagedCollisionEmbeddingBagCollectionSharder, ShardedManagedCollisionEmbeddingBagCollection
  from torchrec.distributed.mc_modules import ShardedManagedCollisionCollection
  from torchrec.distributed.shard import _shard_modules
  from torchrec.distributed.sharding_plan import construct_module_sharding_plan, row_wise
  from torchrec.distributed.test_utils.multi_process import MultiProcessContext, MultiProcessTestBase
  from torchrec.distributed.types import ModuleSharder, ShardingEnv, ShardingPlan
  from torchrec.modules.embedding_configs import EmbeddingBagConfig
  from torchrec.modules.embedding_modules import EmbeddingBagCollection
  from torchrec.modules.mc_embedding_modules import ManagedCollisionEmbeddingBagCollection
  from torchrec.modules.mc_modules import DistanceLFU_EvictionPolicy, ManagedCollisionCollection, MCHManagedCollisionModule
  from torchrec.optim.apply_optimizer_in_backward import apply_optimizer_in_backward
  from torchrec.optim.rowwise_adagrad import RowWiseAdagrad
  from torchrec.sparse.jagged_tensor import JaggedTensor, KeyedJaggedTensor
  from torchrec.test_utils import skip_if_asan_class
label_desc: Use image node_id 4 for calling the ShardedMCEmbeddingBagCollectionParallelTest obj's underlying member method code with example usage: obj.test_sharding_zch_mch_mc_ebc(backend) without return types