Method test_offset_write

tests/unit/ops/aio/test_gds.py:283–327

(self, tmpdir, use_fd, file_partitions)

    @pytest.mark.parametrize('use_fd', [False, True])
    def test_offset_write(self, tmpdir, use_fd, file_partitions):
        ref_file = _get_file_path(tmpdir, '_py_random')
        aio_file = _get_file_path(tmpdir, '_aio_random')
        partition_unit_size = IO_SIZE
        file_size = sum(file_partitions) * partition_unit_size

        h = GDSBuilder().load().gds_handle(BLOCK_SIZE, QUEUE_DEPTH, True, True, IO_PARALLEL)

        gds_buffer = torch.empty(file_size, dtype=torch.uint8, device=get_accelerator().device_name())
        h.pin_device_tensor(gds_buffer)

        file_offsets = []
        next_offset = 0
        for i in range(len(file_partitions)):
            file_offsets.append(next_offset)
            next_offset += file_partitions[i] * partition_unit_size

        ref_fd = open(ref_file, 'wb')
        for i in range(len(file_partitions)):
            src_buffer = torch.narrow(gds_buffer, 0, file_offsets[i],
                                      file_partitions[i] * partition_unit_size).to(device='cpu')

            ref_fd.write(src_buffer.numpy().tobytes())
            ref_fd.flush()

            if use_fd:
                aio_fd = os.open(aio_file, flags=os.O_DIRECT | os.O_CREAT | os.O_WRONLY)
                write_status = h.async_pwrite(buffer=src_buffer, fd=aio_fd, file_offset=file_offsets[i])
            else:
                write_status = h.async_pwrite(buffer=src_buffer, filename=aio_file, file_offset=file_offsets[i])

            assert write_status == 0
            wait_status = h.wait()
            assert wait_status == 1

            if use_fd:
                assert os.path.isfile(aio_fd)
                os.close(aio_fd)

            filecmp.clear_cache()
            assert filecmp.cmp(ref_file, aio_file, shallow=False)

        ref_fd.close()

        h.unpin_device_tensor(gds_buffer)

    def test_offset_read(self, tmpdir, file_partitions):
        partition_unit_size = BLOCK_SIZE