


"""simple docstring"""





import inspect
import os
import unittest

import torch

import accelerate
from accelerate import Accelerator
from accelerate.test_utils import execute_subprocess_async, require_multi_gpu
from accelerate.utils import patch_environment


class      _lowercase (     unittest.TestCase						):


      def _UpperCamelCase						(    self				:	List[str]						):





            """simple docstring"""







            __snake_case      :    Dict  			=inspect.getfile(accelerate.test_utils						)
            __snake_case      :    List[Any]  			=os.path.sep.join(mod_file.split(os.path.sep						)[:-1] + ['''scripts''', '''test_script.py''']						)
            __snake_case      :    Any  			=os.path.sep.join(
                mod_file.split(os.path.sep						)[:-1] + ['''scripts''', '''test_distributed_data_loop.py''']						)
            __snake_case      :    str  			=os.path.sep.join(mod_file.split(os.path.sep						)[:-1] + ['''scripts''', '''test_ops.py''']						)


      @require_multi_gpu
      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            print(f'''Found {torch.cuda.device_count()} devices.'''						)
            __snake_case      :    Union[str, Any]  			=['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', self.test_file_path]
            with patch_environment(omp_num_threads=1						):
                  execute_subprocess_async(__lowercase							,   env=os.environ.copy()						)


      @require_multi_gpu
      def _UpperCamelCase						(    self				:	Any						):





            """simple docstring"""







            print(f'''Found {torch.cuda.device_count()} devices.'''						)
            __snake_case      :    Optional[int]  			=['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', self.operation_file_path]
            print(f'''Command: {cmd}'''						)
            with patch_environment(omp_num_threads=1						):
                  execute_subprocess_async(__lowercase							,   env=os.environ.copy()						)


      @require_multi_gpu
      def _UpperCamelCase						(    self				:	int						):





            """simple docstring"""







            __snake_case      :    List[Any]  			=['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', inspect.getfile(self.__class__						)]
            with patch_environment(omp_num_threads=1						):
                  execute_subprocess_async(__lowercase							,   env=os.environ.copy()						)







      @require_multi_gpu
      def _UpperCamelCase						(    self				:	str						):





            """simple docstring"""







            print(f'''Found {torch.cuda.device_count()} devices, using 2 devices only'''						)
            __snake_case      :    List[Any]  			=['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', self.data_loop_file_path]
            with patch_environment(omp_num_threads=1							,   cuda_visible_devices='''0,1'''						):
                  execute_subprocess_async(__lowercase							,   env=os.environ.copy()						)


if __name__ == "__main__":
    UpperCamelCase_	:				str										= Accelerator()
    UpperCamelCase_	:				Optional[int]										= (accelerator.state.process_index + 2, 10)
    UpperCamelCase_	:				Optional[Any]										= torch.randint(0, 10, shape).to(accelerator.device)

    UpperCamelCase_	:				Optional[Any]										= """"""

    UpperCamelCase_	:				int										= accelerator.pad_across_processes(tensor)
    if tensora.shape[0] != accelerator.state.num_processes + 1:
        error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
    if not torch.equal(tensora[: accelerator.state.process_index + 2], tensor):
        error_msg += "Tensors have different values."
    if not torch.all(tensora[accelerator.state.process_index + 2 :] == 0):
        error_msg += "Padding was not done with the right value (0)."

    UpperCamelCase_	:				List[Any]										= accelerator.pad_across_processes(tensor, pad_first=True)
    if tensora.shape[0] != accelerator.state.num_processes + 1:
        error_msg += F"Found shape {tensora.shape} but should have {accelerator.state.num_processes + 1} at dim 0."
    UpperCamelCase_	:				List[Any]										= accelerator.state.num_processes - accelerator.state.process_index - 1
    if not torch.equal(tensora[index:], tensor):
        error_msg += "Tensors have different values."
    if not torch.all(tensora[:index] == 0):
        error_msg += "Padding was not done with the right value (0)."

    # Raise error at the end to make sure we don't stop at the first failure.
    if len(error_msg) > 0:
        raise ValueError(error_msg)










"""simple docstring"""





from __future__ import annotations



def     __lowercase					(    a :				int       ,		a :				int )					->					list[str]:
      if partitions <= 0:
            raise ValueError('''partitions must be a positive number!''' )
      if partitions > number_of_bytes:
            raise ValueError('''partitions can not > number_of_bytes!''' )
      __snake_case      :    List[str]  			=number_of_bytes // partitions
      __snake_case      :    str  			=[]
      for i in range(a ):
            __snake_case      :    Optional[Any]  			=i * bytes_per_partition + 1
            __snake_case      :    Any  			=(
                number_of_bytes if i == partitions - 1 else (i + 1) * bytes_per_partition
            )
            allocation_list.append(f'''{start_bytes}-{end_bytes}''' )
      return allocation_list


if __name__ == "__main__":
    import doctest

    doctest.testmod()


